Add subtitles to a video
Send a video and get back a timed subtitle file transcribed from its spoken audio, whether it is a two-minute clip or a two-hour lecture. Captions without anyone typing timestamps by hand. Pay per use, no subscription.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & APIauto-generated
What a subtitle file really contains
Subtitle files are older than most people expect. SRT began as a by-product of a Windows video tool in the late 1990s and survived because it is plain text that every player understands; WebVTT came later, designed for the web and HTML5 video. Both boil down to the same idea: a sequence number, a start and an end time, and a line of text. That simplicity is why one file plugs into video editors, course sites and browser players alike. Here the audio of your video is transcribed and cut into those timed captions for you, so nobody has to sit with a stopwatch.
When automatic captions save the most time
A marketing team can caption short clips so the message lands with people watching on mute, without an editor timing every post. A podcast producer can turn recorded video interviews into captioned clips, generating the subtitle file first and trimming highlights afterwards. A media library can create one base subtitle file per video and feed it to a translation step to obtain several language tracks from a single transcription. Keep in mind that the result is a separate file: show it as a track viewers can toggle, or use a burn-in tool if the destination cannot display separate subtitles.
What actually happens to the file
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.
What you can do with it
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
How does automatic subtitle generation work?
The audio track is transcribed and split into short captions, each with a start and an end time, and the result is packaged as a standard subtitle file that video editors and browser players understand.
Can it caption a two-hour lecture?
Yes. The work runs in the background, so a two-minute clip and a two-hour lecture follow the same steps. You are notified when the file is actually ready instead of waiting with a page open.
What can I do with the subtitle file afterwards?
Upload it next to the video as a track viewers can switch on and off, send it to a translation step to build other language versions, or pass it to a separate tool that burns the text into the image.
Why add subtitles to my videos at all?
Many viewers scroll social feeds with the sound off, and courses often have to meet accessibility rules. Captioning by hand is slow and easy to get wrong on names and timing, which is why it pays to automate it.
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
One authenticated POST creates the task; the result comes back by webhook or a signed link. This capability is currently available through the API, not as an interactive Web tool.
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. |
Technical notes
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.
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.
Where it sits in a pipeline
The point is that captioning stops being a manual bottleneck and becomes a predictable, billable step in an otherwise automated publishing chain. 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.
Honest note on rollout
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. This endpoint is in its final deployment phase.
Integration use cases
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.
Technical questions
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.