Add subtitles to a video
Feed a video in, get a caption file out: this endpoint transcribes the spoken audio and returns a standard subtitle file timed to the frame. It exists for the unglamorous but constant task of captioning — courses, product demos, interviews — without anyone sitting there typing timestamps by hand.
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.
Who keeps hitting this wall
Anyone publishing video eventually needs text underneath it: a course platform required to meet accessibility rules, a marketing team that knows most social viewers watch muted, a podcaster repurposing a recorded interview into clips. Manual captioning is slow and easy to get wrong on names and timing, which is exactly the kind of repetitive, precision-dependent work that belongs behind an API call instead of a human with a stopwatch.
What actually happens to the file
You send the video (or a reachable URL to it) to POST /video/subtitles, the job is queued, and a task_id comes back immediately. Behind the scenes the audio track is transcribed and segmented into caption cues with in/out timecodes, then packaged as a subtitle file. Because the work is asynchronous, a two-minute clip and a two-hour lecture both fit the same flow — you're notified when it's actually done instead of holding a connection open.
A quick word on the format
Subtitle files are older than most people expect: SRT started as a side effect of a Windows ripping tool in the late 1990s and stuck around purely because it's plain text and every player understands it, while WebVTT emerged later specifically for the web and HTML5 video. Either lineage boils down to the same idea — a sequence number, a start and end timestamp, and a line of text — which is why the output plugs cleanly into video editors, LMS platforms, and browser players alike.
Where it sits in a pipeline
Treat this endpoint as one stage: raw video comes in, a caption file comes out, and what happens next is up to you. That file can be uploaded next to the video as a soft, toggle-able track, handed to a translation step for multilingual versions, or passed straight to a burn-in stage when the destination platform doesn't support separate subtitle tracks at all. The point is that captioning stops being a manual bottleneck and becomes a predictable, billable step in an otherwise automated publishing chain.
Honest note on rollout
This endpoint is in its final deployment phase. The path, pricing and job shape described here are the ones that will ship; once it opens for traffic, requests that fail before completion are never billed.
What you can do with it
Course platforms meeting accessibility requirements
An e-learning provider runs every new lecture video through the endpoint overnight so captions are ready before the module goes live, instead of a person transcribing each recording by hand.
Social clips built for sound-off viewing
A marketing team captions short-form video automatically so the message lands with viewers scrolling on mute, without a dedicated editor doing timestamp work for every post.
Podcast-to-video repurposing
A podcast producer converts recorded video interviews into captioned clips for distribution, generating the subtitle file as the first automated step before an editor trims highlights.
Multilingual archives
A media library generates a base subtitle file per video and feeds it into a translation workflow to produce several language tracks from one transcription pass.
FAQ
What format does the video subtitle generator API return?
It returns a standard timed subtitle file (SRT-style cues with start and end timecodes) that plays as a soft, toggleable track in players and editors that support it.
Is this video subtitle 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.
How do I get the finished captions?
You'll get the result through a signed webhook call when the job completes, or you can fetch it from a signed link that stays valid for 24 hours.
Can I caption a two-hour video in one request?
Yes — because the job runs asynchronously and returns a task_id right away, video length doesn't force you to hold a connection open; you're notified when the transcription finishes.
Do I need to burn the subtitles into the picture?
No, this endpoint produces a separate subtitle file. If your destination platform doesn't support soft subtitle tracks, pair the output with the burn-in subtitles endpoint.
Is the endpoint accepting jobs right now?
It's completing final deployment; the path, price and behavior documented here are final and it will open for requests shortly.
What happens to my video after processing?
The file is deleted after the retention window and is never used to train models — results are delivered privately by webhook or signed link.
Can I run this in bulk across a video library?
Yes, since each call is a stateless async job identified by its own task_id, queuing hundreds of videos through the same endpoint is a matter of looping the request, not a special bulk mode.
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, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/video/subtitles \
-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/video/subtitles", {
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/video/subtitles",
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/video/subtitles", 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/video/subtitles", 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": "video.subtitles",
"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. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |