Normalize loudness
One clip hits your ears at a whisper and the next one three seconds later feels like it's shouting, and that jump is usually the difference between someone finishing your audio and someone reaching for the volume knob. This endpoint brings every file to a consistent, comfortable loudness so the listener never has to.
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 loudness drifts in the first place
Two speakers on the same podcast recorded on different microphones, at different distances, on different days, will never come out at the same volume by accident — physics and hardware see to that. Stack a dozen episodes, or a batch of voiceovers from different narrators, or clips pulled from a dozen source videos, and the inconsistency compounds into something a listener notices even if they can't name it. audio.normalize targets exactly that drift, treating it as a solvable engineering problem rather than something every producer has to fix by ear, episode by episode, on every single release.
What actually happens to the file
POST /audio/normalize with your file, and the task runs asynchronously against a standard loudness target, returning a task_id immediately. The normalized file arrives by signed webhook or waits at a signed link valid for 24 hours — the loudness curve is adjusted throughout the file, not just peaks clipped down, so quiet passages and loud passages both land in a comfortable, consistent range relative to each other.
Loudness is not the same thing as volume
Broadcast and streaming platforms adopted loudness normalization standards for a reason: turning a file up or down uniformly doesn't fix a track that's simply mixed inconsistently within itself, and simple peak limiting can leave quiet sections still sounding quiet next to loud ones. Proper loudness normalization looks at how the human ear perceives volume over time, not just the highest sample value, which is why two files normalized this way sound evenly matched even if their waveforms look very different.
Where it belongs in a production chain
Run normalize after trimming and denoising and before final delivery, so it's working with the cleanest version of the audio rather than trying to smooth out background hiss along with the voice. Podcast networks run it across every episode before publishing so listeners never have to touch the volume between shows, and audiobook producers run it across every chapter so a book doesn't get louder or quieter as the narrator's energy shifts. Billed per request plus per minute, normalizing a whole back catalog costs in direct proportion to its total runtime, nothing more.
What you can do with it
Consistent podcast episodes
A podcast network normalizes every episode to the same loudness target before publishing so listeners don't reach for the volume dial between shows.
Multi-narrator audiobook chapters
An audiobook producer normalizes chapters recorded by different narrators so the whole book plays at one consistent, comfortable level.
User-generated voice clips
A social app normalizes voice messages recorded on wildly different phones so playback volume feels the same across every clip in a feed.
Ad and music bed matching
A video editor normalizes a licensed music bed and a recorded voiceover so neither one overpowers the other during playback.
FAQ
How do I normalize audio loudness with the API?
POST the file to /audio/normalize, keep the returned task_id, and collect the normalized file by webhook or a signed link valid for 24 hours.
Is the audio normalization 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 normalization is never charged.
Does normalizing just turn up the volume?
No, it adjusts the loudness curve across the file toward a consistent target, which is different from a simple uniform volume boost or a hard peak limiter.
Will normalizing fix distorted or clipped audio?
No, normalization evens out perceived loudness but cannot recover audio that was already clipped or distorted during the original recording.
What formats can I normalize?
The common ones — MP3, WAV, OGG, M4A and FLAC; check the endpoint reference for the current full list.
Should I normalize before or after removing noise?
Denoise first, then normalize, so the loudness target is calculated from clean audio rather than boosted alongside background hiss.
Is this endpoint live yet?
It's in deployment now and not yet accepting jobs; check the endpoint status before pointing production traffic at it.
Is my audio kept after processing?
No, files and results 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/normalize \
-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/normalize", {
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/normalize",
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/normalize", 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/normalize", 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.normalize",
"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. |