Peak normalization gain calculator
This peak normalization gain calculator converts a measured audio peak and a desired peak into the exact gain adjustment required.
Run — free
Enter both levels in dBFS and receive a positive gain for amplification, a negative gain for attenuation, or zero when the audio already meets the target. Targets above 0 dBFS are rejected because they would exceed digital full scale. The calculation is deterministic and works without uploading, decoding, or changing an audio file.
Turn two peak readings into one usable gain setting
Peak normalization starts with a simple practical question: how far is the loudest measured sample from the level you want it to reach? Provide the current peak in dBFS and the intended target peak in dBFS. The calculator subtracts the current value from the target and reports the difference as gain in decibels. If a recording peaks at -8.4 dBFS and the target is -1 dBFS, the required adjustment is +7.4 dB. A positive result means amplification; a negative result means attenuation. A result of zero means no level change is needed. The response repeats both inputs, reports the resulting peak, and confirms that the requested target does not clip. This makes the output convenient for scripts, batch manifests, gain plug-ins, command-line audio tools, or a manual editing checklist. The calculation does not inspect audio samples, estimate loudness, or apply processing. It gives the exact gain setting from peak measurements you already trust, keeping measurement and adjustment as separate, auditable steps.
Choose a target that preserves the headroom you need
In dBFS, 0 dBFS represents digital full scale, so a target above zero would request a peak beyond the available digital ceiling. This calculator rejects such targets instead of returning a gain that promises clipping. A target of exactly 0 dBFS is mathematically valid, although many production workflows choose a lower value such as -1 dBFS to retain headroom for encoding, conversion, resampling, or later signal processing. Select that margin according to the delivery specification for your project rather than treating one target as universally correct. The tool accepts any finite current peak measurement, including a positive value from a meter that reports inter-sample or true-peak overs. In that situation, a safe non-positive target produces negative gain and therefore attenuation. Remember that sample peak and true peak are different measurements: the arithmetic is the same, but the two input values should come from the same measurement convention. Mixing a sample-peak reading with a true-peak delivery requirement can make a numerically correct result unsuitable for the intended quality-control standard.
Apply the result without confusing peak level and loudness
Use the returned gain as a uniform level change in an editor, digital audio workstation, encoder, or processing pipeline. After applying it, measure the output again with the same meter that produced the original peak. Rechecking catches changes introduced by effects, lossy encoding, sample-rate conversion, limiting, or rounding elsewhere in the chain. Peak normalization changes every sample by the same gain and therefore preserves the existing dynamics; it does not make quiet passages independently louder, reduce the crest factor, or match perceived loudness between different programs. For podcast, broadcast, music, or streaming delivery, you may also need an integrated loudness target in LUFS and a true-peak ceiling. Those are separate constraints and can require loudness normalization or limiting rather than this single subtraction. This capability is most useful when the current peak has already been measured and you need a transparent, reproducible gain instruction. Because it performs no upload or audio decoding, it is also suitable for lightweight automation that stores measurements in metadata and computes adjustments before a dedicated audio processor applies them. API requests cost $0.002 each.
What you can do with it
Prepare a gain command
Convert a measured peak and delivery ceiling into the gain value required by an editor, plug-in, or command-line processor.
Attenuate an over-level master
Calculate the negative gain needed to bring a positive true-peak reading down to a safe non-positive target.
Build a batch normalization manifest
Compute deterministic gain instructions from previously measured peaks without uploading or decoding the source audio again.
FAQ
What formula does the calculator use?
Gain in dB equals target peak in dBFS minus current peak in dBFS.
Why can the target not exceed 0 dBFS?
Zero dBFS is digital full scale. A higher target would request a peak beyond that ceiling and would clip in a conventional digital signal path.
What does a negative gain result mean?
It means the current peak is above the target and the audio should be attenuated by the reported amount.
Does this normalize perceived loudness?
No. It calculates uniform gain from peak levels only. Loudness matching based on LUFS is a different process.
Can I use a true-peak measurement?
Yes. Use a current and target value based on the same true-peak convention, then verify the processed output with the same type of meter.
What does an API request cost?
Each API request costs $0.002; the browser calculation is available directly on the page.
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/audio/audio-normalize-peak-target \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"current_peak_dbfs":-8.4,"target_peak_dbfs":-1}'const res = await fetch("https://api.kit.forhosting.com/audio/audio-normalize-peak-target", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"current_peak_dbfs": -8.4,
"target_peak_dbfs": -1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/audio/audio-normalize-peak-target",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"current_peak_dbfs": -8.4,
"target_peak_dbfs": -1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/audio/audio-normalize-peak-target", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"current_peak_dbfs":-8.4,"target_peak_dbfs":-1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"current_peak_dbfs":-8.4,"target_peak_dbfs":-1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/audio/audio-normalize-peak-target", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"current_peak_dbfs": -8.4,
"target_peak_dbfs": -1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "audio.audio_normalize_peak_target",
"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. |