Convert a video
A video file is only as useful as the systems that will actually open it, and no single format satisfies every one of them — this endpoint converts between MP4, WebM, MOV, AVI and MKV so the same source footage can land wherever it needs to, correctly, without a desktop app in the loop.
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.
Why format still matters in 2026
Containers and codecs never fully converged: MOV still shows up from camera and editing workflows, AVI persists in older broadcast and archival systems, MKV is common in open-source and enthusiast pipelines, while MP4 and WebM dominate the modern web because browsers and mobile platforms were built around them. A team receiving footage from one world and publishing into another runs into this constantly — not as an edge case, but as a routine mismatch between what was delivered and what the destination will actually accept.
What the conversion job actually does
Call POST /video/convert with the source file and the target format, and the request returns a task_id while conversion runs in the background. The service re-packages, and where necessary re-encodes, the video and audio streams into the target container and codec pairing, preserving the content while changing the wrapper it travels in — the same footage, just readable by a different set of tools.
Containers versus codecs, briefly
It's worth separating the two ideas the format names actually represent: MP4 and MKV are containers, boxes that can hold different codec combinations inside, while the codec (commonly H.264 or H.265 for video today) is what actually compresses the picture. This endpoint handles both layers of the problem, choosing sensible defaults for the target container so the output plays reliably rather than technically matching a spec but failing silently on some player.
The automation angle
Format conversion rarely happens in isolation — it's usually one link in a chain that starts with an upload from a camera or a client and ends with a specific platform's ingest requirements, whether that's a CMS, an ad network, or a streaming pipeline with its own format rules. Making that conversion an API call rather than a manual export means the same rule can run unattended across an entire library, night after night, instead of someone re-running it by hand for every new file that shows up.
Where things stand today
This endpoint is finishing its final deployment. Everything documented here — the path, the supported formats, the pricing — is the version that will ship, and as with every task on the platform, three retries happen automatically before a failure is ever reported, and a failed conversion is never billed.
What you can do with it
Camera footage prepped for the web
A production team receives raw MOV files from cameras and converts them to MP4 automatically before handing footage to a web-facing publishing pipeline.
Archival footage brought into modern tooling
An archive holding older AVI recordings converts them to MKV or MP4 in bulk so the collection becomes playable in current editing and streaming tools.
Platform-specific delivery requirements
An ad network requires a specific container and codec combination, so a media team converts every creative to that exact format automatically before submission.
Open-source and cross-platform pipelines
A development team standardizes internal video assets on MKV for editing flexibility, then converts to WebM specifically for the web build of their product.
FAQ
Which formats does this video converter API support?
It converts between MP4, WebM, MOV, AVI and MKV, handling both the container and the underlying codec so the result actually plays on the target platform.
Is the video converter 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.
Does converting a video reduce its quality?
Converting between containers with a compatible codec preserves quality closely, while converting between codecs involves re-encoding, so output settings and target format both affect the final result.
How is the converted file delivered?
Through a signed webhook when the job finishes, or from a signed link valid for 24 hours after conversion completes.
Can I convert a large batch of videos at once?
Yes, since every conversion is an independent async task with its own task_id, converting an entire library is just a matter of submitting one request per file.
What happens if a conversion fails?
The task is retried automatically up to three times; if it still fails, you get a clear error and are never charged for that attempt.
Is MOV to MP4 conversion supported?
Yes, MOV to MP4 is one of the most common conversions this endpoint handles, along with AVI and MKV in either direction to MP4 or WebM.
Is this endpoint live right now?
It's in final deployment; the formats, endpoint and pricing described here are the final version and it will begin accepting jobs soon.
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/convert \
-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/convert", {
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/convert",
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/convert", 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/convert", 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.convert",
"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. |