ForHosting KIT · Video

Calculate total render queue time and completion time

A render queue is easier to plan when every clip estimate becomes one clear finish time.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

Runs in your browser. Free, unlimited — your data never leaves this page.

Enter the clips in processing order, give each one an estimated render duration in seconds, and set the UTC time when work begins. The calculator adds the queue without overlap and returns the total in seconds, a readable duration, and the estimated UTC completion timestamp. It is useful for editors, motion designers, producers, and render-farm operators who need a deterministic schedule from estimates they already trust, without uploading media or relying on a live rendering system.

Build a queue from realistic clip estimates

Start by listing every clip that will be processed by the same sequential render worker. Give each row a recognizable name and an estimated render duration in whole seconds. The name helps you review the input, while the duration is the number used in the calculation. Include setup-heavy title sequences, short transitions, revisions, and delivery versions when they will occupy the worker separately. Do not enter source-video running time unless it is also your expected render time; effects, resolution, codecs, and hardware can make those values very different. Estimates from a recent test render are usually more useful than guesses based only on timeline length. The calculator treats the rows as one uninterrupted queue and sums every duration, including zero-second placeholders. It does not inspect media or adjust the figures. This keeps the result transparent: if a clip estimate changes, update that row and calculate again to see the revised queue finish immediately. An empty list is rejected because it cannot represent an actual render queue workload.

Choose an unambiguous UTC start time

Set the moment when the first clip is expected to begin using the UTC form YYYY-MM-DDTHH:mm:ssZ. For example, a timestamp ending in Z is explicitly UTC and therefore does not depend on the computer, browser, editor, or render node that performs the calculation. This matters when a producer and a remote render operator work in different time zones, or when a queue crosses a daylight-saving transition. Convert a local handoff time to UTC before entering it, and keep the original local-zone note in your production schedule if colleagues need it. The capability validates the calendar itself, including month lengths and leap years, before adding the queue duration. It then performs exact Gregorian calendar arithmetic, so a queue can cross midnight, the end of a month, New Year, or February 29 without special handling from you. Seconds are preserved exactly. The returned start time and estimated completion time use the same UTC notation, making them suitable for logs, automation, and later comparison.

Interpret the completion estimate responsibly

The result contains the number of clips, total queue seconds, a readable day-and-clock duration, the supplied start timestamp, and the estimated completion timestamp. The completion value assumes one worker processes every listed clip sequentially with no gaps or overlap. It is therefore a scheduling baseline, not a promise that a render farm will finish at that exact instant. Add expected upload, download, validation, retry, machine warm-up, and review time outside the queue when those activities consume real schedule time. If multiple workers render clips in parallel, divide the jobs into the actual worker queues and calculate each queue separately; the latest completion among them is the batch estimate. Teams can also compare optimistic, expected, and conservative scenarios by running the same clip list with different duration estimates. Because the calculation uses no live system data, it is reproducible: identical inputs always return identical output. That makes it appropriate for planning notes, production handoffs, budget discussions, and automated status summaries where assumptions must remain visible and auditable.

Plan an overnight render

Add the queued shots and check whether the estimated finish falls before the morning review window.

Coordinate a remote handoff

Share one UTC completion estimate with editors and render operators working across several time zones.

Compare queue scenarios

Run optimistic and conservative clip estimates to expose schedule risk before committing to a deadline.

What does the calculation cost?

The browser calculation is free on this page. An API request costs $0.002.

Does the calculator render or inspect my clips?

No. It uses only the names, estimated render seconds, and UTC start time you provide; no media is uploaded or inspected.

Can render times include fractions of a second?

No. Each estimate must be a non-negative whole number of seconds so the queue and completion timestamp remain exact.

Does it support parallel render workers?

The calculation models one sequential queue. For parallel workers, calculate each worker queue separately and use the latest completion time.

Why must the start time be UTC?

UTC removes local-zone and daylight-saving ambiguity, so collaborators and automated systems receive the same completion timestamp.

What happens if the clip list is empty?

The request returns an invalid-input error because a queue must contain at least one clip.

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.

POSThttps://api.kit.forhosting.com/video2/render-queue-time-total

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.

curl -X POST https://api.kit.forhosting.com/video2/render-queue-time-total \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"clips":[{"name":"Opening titles","estimated_render_seconds":95},{"name":"Main sequence","estimated_render_seconds":430},{"name":"End card","estimated_render_seconds":35}],"start_time":"2026-08-03T14:20:00Z"}'
{
  "clips": [
    {
      "name": "Opening titles",
      "estimated_render_seconds": 95
    },
    {
      "name": "Main sequence",
      "estimated_render_seconds": 430
    },
    {
      "name": "End card",
      "estimated_render_seconds": 35
    }
  ],
  "start_time": "2026-08-03T14:20:00Z"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "video2.render_queue_time_total",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_items1000
max_total_seconds3155760000
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →