Convert audio
Every device, player and pipeline seems to want a different container for the same sound. This endpoint takes whatever you have and hands back whatever format the next system in line actually needs.
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.
One file, five expectations
A voice memo recorded on a phone lands as M4A, a podcast host wants WAV masters, a web player wants MP3, and an archive policy insists on FLAC for anything kept long-term. Nobody sits down and manually re-exports the same recording five times on purpose; they do it because the alternative is a broken upload or a player that silently refuses the file. audio.convert is built for that exact friction: one input, the container your next step actually requires.
How the conversion runs
Send POST /audio/convert with the source file and the target format, and you get back a task_id immediately while the conversion runs in the background. When it finishes, the converted file arrives through a signed webhook call or waits behind a signed link valid for 24 hours, whichever fits how your system checks for completed work.
Lossy, lossless, and why both still exist
MP3 and OGG throw away audio data the human ear is less likely to miss, trading a bit of fidelity for a much smaller file, which is why streaming and mobile playback still lean on them decades after MP3 first shipped. WAV and FLAC keep everything: WAV stores raw uncompressed samples, FLAC compresses without discarding anything, so masters and archival copies still favor them. M4A sits in between as a modern, efficient lossy container common on phones and in Apple's ecosystem. Converting between these families isn't just a rename — it's a real re-encode, and the endpoint handles that correctly in both directions.
Where it slots into a bigger workflow
A media pipeline that ingests user uploads in whatever format arrives, normalizes everything to one internal standard, and only converts back out at delivery time, is a pipeline that stops fighting format mismatches. Because the task is async and billed per request plus per minute of audio, batching a thousand files overnight costs the same per unit as converting one file by hand — it just doesn't require a human standing over each one. That predictability matters more than it sounds: a team that once budgeted engineering time to babysit a format-conversion script can instead treat conversion as a fixed line item, submit the whole queue at once, and move on to the next stage of the pipeline while the results land on their own schedule.
What you can do with it
Podcast ingestion normalization
A podcast host accepts WAV, M4A or whatever a guest recorded, then converts everything to a consistent MP3 before publishing to distribution feeds.
Voicemail to shareable clip
A support platform converts M4A voicemail recordings to MP3 so they can be embedded in a ticket without requiring a special player.
Archival masters in FLAC
A music library converts incoming WAV session files to FLAC to shrink long-term storage costs without losing any audio fidelity.
Legacy player compatibility
An e-learning platform converts OGG lecture recordings to MP3 so older hardware and browsers that don't support OGG can still play them.
FAQ
How do I convert audio with the API?
POST the source file and target format to /audio/convert, keep the returned task_id, and collect the converted file by webhook or a signed link valid for 24 hours.
Is the audio converter API free?
No, there is no free tier or trial; it costs $0.077 per request plus $0.0045 per minute of audio, and a failed conversion is never charged.
Which formats does it support?
MP3, WAV, OGG, M4A and FLAC, converting between any of them in either direction.
Will converting lossy to lossless improve quality?
No — converting MP3 or OGG to WAV or FLAC changes the container but cannot restore audio data already discarded during the original lossy encode.
Can I convert many files in bulk?
Yes, submit one async task per file and collect each result by webhook as it finishes, which is how most batch integrations are built.
Is this endpoint live yet?
It's in deployment now; check the endpoint status before sending production traffic, since it isn't accepting jobs at this moment.
Does file length affect the price?
Yes, price is a flat per-request fee plus a per-minute rate based on the audio's duration, so cost scales predictably with length.
Is my audio stored after conversion?
No, source and converted files are deleted after the retention window and are never used for training.
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/audio/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/audio/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/audio/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/audio/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/audio/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": "audio.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 | 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. |