WebVTT captions
Send an audio track and get back a .vtt file with the WEBVTT header, timed cues and readable lines, ready to link from the track element of an HTML5 video. Long recordings keep their timing across every seam. Pay per use, no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
The HTML5 video tag was built expecting a specific caption format, and it isn't .srt — it's WebVTT.
The caption format the web was built for
When browsers gained native video playback, they needed a caption format designed for the web rather than inherited from desktop subtitle tools. WebVTT fills that role: a text-based structure with room for styling and positioning cues, maintained alongside HTML itself. It is the format the track element expects by default, so a page can show captions on an HTML5 video without a plugin or a third-party player. The file you receive starts with the WEBVTT header and contains correctly formatted timecodes and cue text.
Timing, long recordings and other languages
Each caption line is timed against the actual audio rather than cut at fixed intervals, so text appears and clears in step with speech instead of lagging or interrupting mid-sentence. Long recordings are processed in chunks, with the timing kept consistent across the seams, so a caption near a boundary still lands in the right place. Publishers use it for native captions, software teams for accessible tutorial videos, and course sites generate one track, translate the text and offer several caption tracks on the same video. Review names and technical terms before you publish.
Why the web needed its own subtitle format
When browsers gained native video playback, they needed a caption format designed for the web rather than inherited from desktop subtitle rippers — one with a text-based structure, room for styling and positioning cues, and a spec maintained alongside HTML itself. WebVTT was built for exactly that role, and it's the format the track element expects by default when a page wants captions on an HTML5 video without a plugin or a third-party player.
How the captions get timed
Each caption line is timed against the actual audio track rather than split at arbitrary intervals, so text appears and clears in step with speech instead of lagging behind it or interrupting mid-sentence. Long recordings are chunked automatically during processing, with timing kept consistent across the seams so a caption near a chunk boundary still lands correctly in the final file.
What you can do with it
Native HTML5 video captions
A publisher embeds a video tag with a track element pointing to the generated .vtt file, giving native captions with no external player library.
Web app video accessibility compliance
A SaaS product adds WebVTT captions to in-app tutorial videos to meet accessibility requirements for its embedded player.
Streaming platform caption pipeline
A video platform generates .vtt files automatically as part of its upload pipeline so every new video ships with captions by default.
Multilingual caption tracks
A course site generates a base .vtt track, translates the text, and offers multiple .vtt caption tracks on the same HTML5 video.
FAQ
Does the output work directly with the HTML5 track tag?
Yes, the file follows the WebVTT spec exactly, so it can be referenced directly from a track element's src attribute with no reformatting.
How accurate is the caption timing?
Each caption line is timed against the actual audio and split at natural speech pauses, so text tracks what's being said rather than drifting or cutting mid-sentence.
What languages are supported?
The same broad language coverage as standard transcription applies, with automatic language detection or an explicit setting.
What happens if caption generation fails?
The task retries automatically up to three times before returning a clear error, and a failed request is never charged.
Should I generate .vtt or .srt captions?
Use .vtt for captions on a web page: an HTML5 video reads it directly through a track element with nothing else to set up. Desktop editors and many upload workflows still favour .srt, so many projects simply keep one of each.
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/audio/subtitles-vtt \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"audio":"https://ejemplo.com/audio.mp3"}'const res = await fetch("https://api.kit.forhosting.com/audio/subtitles-vtt", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"audio": "https://ejemplo.com/audio.mp3"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/audio/subtitles-vtt",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"audio": "https://ejemplo.com/audio.mp3"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/audio/subtitles-vtt", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"audio":"https://ejemplo.com/audio.mp3"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"audio":"https://ejemplo.com/audio.mp3"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/audio/subtitles-vtt", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"audio": "https://ejemplo.com/audio.mp3"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "audio.subtitles_vtt",
"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 | 200 |
max_minutes | 180 |
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. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |
Technical notes
This endpoint transcribes an audio track and returns a .vtt file formatted to the web standard, ready to reference from a track tag without any conversion step in between.
What comes out of the endpoint
POST an audio file to /audio/subtitles-vtt and the task transcribes the speech, breaks it into readable caption lines at natural pauses, and writes the result as a valid WebVTT file — the WEBVTT header, correctly formatted timecodes, and cue text in the structure the spec requires. It's a file ready to sit next to a video and be linked directly, not raw text needing manual formatting.
Where WebVTT fits versus other formats
A native HTML5 video player reads a .vtt file directly through a track element with zero extra code; .srt still dominates in desktop editors and many upload workflows built around it. Because both formats describe the same underlying information — timed caption lines — most projects that need both simply generate an .srt for editing and delivery pipelines and a .vtt specifically for the web player, and this endpoint's sibling handles the .srt side.
Pricing and how failures are handled
The cost is a small base fee per request plus a per-minute rate scaled to audio length, the same transparent structure as plain transcription work. The task runs asynchronously — submit audio, receive a task_id right away, and get the .vtt file by signed webhook or a signed link valid for 24 hours; if generation fails it retries automatically up to three times and is never billed if it still doesn't complete.
Technical questions
How do I generate a .vtt file from audio with this API?
POST an audio file to /audio/subtitles-vtt and the task returns a standards-compliant WebVTT file via webhook or a signed link, ready to reference from an HTML5 track element.
What's the difference between VTT and SRT here?
Both carry timed caption text, but WebVTT is the format HTML5 video natively expects; the sibling SRT subtitle endpoint produces the .srt version for editors and platforms that expect that format instead.
Is the WebVTT generator API free to use?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
Can I generate captions for many videos at once?
Yes, each audio file is submitted as its own asynchronous request, so a batch can be queued together and each .vtt file collected by webhook as it finishes.