ForHosting KIT · Video

Compute video thumbnail timestamps evenly

Plan a clean set of preview images before decoding a single video frame. Provide the video duration and the number of thumbnails you want, and this calculator returns deterministic, evenly spaced timestamps in seconds.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

It deliberately keeps every selection out of the first and last second, where fades, blank frames, title cards, and end screens often make weak previews. The result is ready for an extraction command, media pipeline, storyboard generator, or video player timeline.

Choose representative points without sampling the edges

A useful thumbnail set should summarize the video rather than merely divide its raw duration. The opening instant commonly contains a black frame, a fade from black, a loading slate, or an incomplete keyframe. The final instant is similarly likely to show a fade, credits, an end card, or no decodable frame at the exact duration boundary. This calculator removes those unreliable regions by defining a usable window from one second after the start to one second before the end. When you request two or more timestamps, it places the first selection at the beginning of that safe window, the last selection at its end, and distributes every other selection at equal intervals. If you request one timestamp, it returns the midpoint of the video. This behavior is explicit and repeatable, so the same duration and count always produce the same schedule. You can feed those seconds directly into a separate frame extraction process without writing spacing logic for every application or accidentally requesting the inaccessible endpoint of a media file.

Understand the calculation and its boundaries

The input uses seconds and accepts fractional video durations, which is important because media metadata rarely lands on a whole second. For multiple thumbnails, the spacing equals the usable duration, meaning the total duration minus two seconds, divided by one less than the requested count. Each timestamp is then the first safe second plus that spacing multiplied by its zero-based position. Results are rounded to no more than six decimal places to keep JSON output stable while retaining sub-second precision for normal preview extraction. A duration must be greater than two seconds because a shorter clip has no interval that excludes both its first and last second. The count must be an integer of at least one; a zero or negative count has no meaningful thumbnail schedule and returns an input error. The upper bounds protect the browser and API from unnecessarily large arrays. This tool computes positions only. It does not inspect frames, detect scene changes, locate keyframes, or guarantee that a decoder will seek to the exact requested fraction of a second.

Use the timestamps in a thumbnail workflow

Start with the authoritative duration reported by your media probe, player metadata, or upload service. Choose a count that matches the destination: a compact hover preview may need only a few frames, while a long-form storyboard may need dozens. Send those values to the calculator and preserve the returned order when extracting images. Most video tools accept a timestamp in seconds or can convert it to their own time notation. Because the schedule is evenly spaced, it is also suitable for deterministic cache keys and repeatable background jobs: if an extraction task is retried, it asks for the same positions. Keep in mind that frame accuracy depends on the extractor. Some fast seek modes jump to a nearby keyframe, while accurate seek modes decode forward to the requested time. For content-aware coverage, use scene detection after or instead of this calculation. For predictable timeline coverage, batch planning, test fixtures, and player preview strips, these timestamps provide a small, transparent contract that is easy to reproduce in any system.

Build a player preview strip

Generate predictable positions for the images shown when a viewer scrubs across a video timeline.

Plan a video storyboard

Create a uniformly sampled contact sheet without selecting blank opening frames or end screens.

Schedule batch frame extraction

Pass a stable timestamp array to an FFmpeg job, media worker, or upload processing pipeline.

What does it cost?

Each API request costs $0.002. You can also run the calculator in your browser.

Why are the first and last second excluded?

Those regions often contain fades, blank frames, title slates, credits, or an undecodable duration boundary, so they commonly produce poor previews.

What happens when I request one thumbnail?

The calculator returns the midpoint of the video, which lies inside the safe window for every accepted duration.

Does this tool extract the thumbnail images?

No. It returns timestamps only. Use the result with a video decoder or frame extraction tool.

Are fractional seconds supported?

Yes. The duration and returned timestamps may contain fractions, with output rounded to at most six decimal places.

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/video/thumbnail-timestamps

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/video/thumbnail-timestamps \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"duration_seconds":120,"count":5}'
{
  "duration_seconds": 120,
  "count": 5
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "video.thumbnail_timestamps",
  "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_items10000
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 →