Reverb decay time from BPM calculator
At 120 BPM one beat lasts 500 ms, so a reverb tail of 4 beats needs a decay of 2000 ms: enter the tempo and the number of beats and get the time to type into your reverb. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Bpm
- 120
- Beats
- 4
- Beat ms
- 500 ms
- Ms per beat
- 500
- Decay ms
- 2,000
- Reverb decay ms
- 2,000
A reverb decay time from BPM calculator turns a song tempo and a chosen tail length in beats into the exact milliseconds you type into a reverb plugin, multi-FX unit, or send return. Producers often want the wash to finish on a bar line or after a set number of quarter notes rather than guessing a free-running RT60. Enter the project BPM and how many beats the tail should last; the tool returns the quarter-note pulse in milliseconds, the decay time in milliseconds and seconds, a short formula, and ordered steps you can check by hand.
How tempo and beat count become a reverb decay in milliseconds
Beats per minute counts how many quarter-note pulses occur in sixty seconds under the usual production convention that one beat equals one quarter note in 4/4. The reciprocal is universal: milliseconds per beat equal sixty thousand divided by the tempo, so one hundred twenty BPM yields five hundred milliseconds per quarter note, one hundred BPM yields six hundred milliseconds, and sixty BPM yields one thousand milliseconds. A tempo-synced reverb decay simply multiplies that pulse by the number of beats you want the tail to last.
Four beats at one hundred twenty BPM therefore last two thousand milliseconds; two beats last one thousand; a dotted two-beat feel of one point five beats lasts seven hundred fifty milliseconds. That product is the value many engineers paste into decay, RT60-style, or size fields when they want the wash to clear before the next phrase rather than ring freely against the next downbeat.
Rejecting non-positive BPM or non-positive beat counts is essential: division by zero, a negative pulse, or a negative length would invent non-physical times that break session recall and MIDI automation.
What you can do with it
Match multi-FX and send returns across a set
Live engineers compute tempo-synced tails for several songs so hardware multi-FX units and DAW sends share consistent beat-locked decay times.
FAQ
How do you calculate reverb decay time from BPM?
Milliseconds per quarter-note beat equal 60000 divided by BPM.
What happens if BPM or beats is zero or negative?
Tempo-synced decay times are undefined for non-positive tempo or beat count.
Is one beat always a quarter note?
Yes for this calculator. It follows the standard production convention that BPM counts quarter-note pulses, which matches most DAW tempo maps in 4/4.
Is this the same as a full BPM to milliseconds note table?
No. This tool returns one reverb decay length from a chosen beat count. A BPM-to-milliseconds calculator returns full note-value and delay-preset tables without a tail-length input.
Is the reverb decay time from BPM calculator free?
The browser tool is free and runs locally.
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
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/hobby/music-reverb-decay \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bpm":120,"beats":4}'const res = await fetch("https://api.kit.forhosting.com/hobby/music-reverb-decay", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bpm": 120,
"beats": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/music-reverb-decay",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bpm": 120,
"beats": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/music-reverb-decay", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bpm":120,"beats":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bpm":120,"beats":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/music-reverb-decay", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"bpm": 120,
"beats": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.music_reverb_decay",
"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.
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. |
Technical notes
Non-positive tempos or beat counts are rejected with invalid_input so automation never stores a negative or infinite decay.
How to call the API and what comes back
Tempo must stay strictly greater than zero and at most one thousand BPM; the beat count must stay strictly greater than zero and at most one million. The steps array walks from the raw tempo through the beat duration, the multiply by beat count, and the conversion to seconds so you can assert intermediate values in tests. Send a JSON body with two required finite numbers: bpm, also accepted under the aliases tempo, beats_per_minute, and tempo_bpm; and beats, also accepted as num_beats, beat_count, decay_beats, or tail_beats. Missing fields, non-numeric strings, non-finite values, and out-of-range numbers return invalid_input and are never charged. On success the response echoes the rounded bpm and beats, sets beat_ms and ms_per_beat to the quarter-note duration in milliseconds, sets decay_ms and reverb_decay_ms to the same tail length in milliseconds, sets decay_seconds to that length divided by one thousand, unit to the string ms, formula to the closed relation decay_ms equals sixty thousand over bpm times beats with one beat equal to a quarter note, and message to a short English summary. Pricing is a flat $0.002 per successful request with unit item.
Practical tips, limits, and related searches
Prefer sending numbers rather than pre-formatted strings when you control the client; string numbers are accepted only when they match a strict finite numeric pattern. Common studio checkpoints are easy to memorize: one hundred twenty BPM with four beats is two thousand milliseconds; one hundred twenty-eight BPM with two beats is nine hundred thirty-seven point five milliseconds; seventy-two BPM with one beat is eight hundred thirty-three point three recurring milliseconds. Prefer this capability when you already know the project tempo and only need the tail length in milliseconds; if you need every note-value and delay preset for the same tempo, use a dedicated BPM-to-milliseconds table instead. Keep BPM inside the published range so the reciprocal beat duration stays finite in IEEE double precision on the Worker and in the browser. When teaching, pair a positive happy path with a deliberate zero or negative tempo or beat count to demonstrate the hard invalid_input path. This landing targets people searching for a reverb decay time calculator from BPM, tempo-synced reverb ms, or beats-to-decay-time tool; it is not a geometric RT60 room calculator, not a full delay-note table, not a pre-delay or wet-dry mixer, and not a real-time audio processor. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately probe edge cases. Round-trip checks are straightforward: recompute sixty thousand divided by bpm, multiply by beats, and confirm it equals decay_ms within twelve-decimal rounding.
Integration use cases
Set plugin reverb decay to finish on the bar
Producers enter session BPM and a 2- or 4-beat tail, then paste decay_ms into reverb decay or size fields so the wash clears before the next phrase.
Unit tests for tempo-aware mix helpers
Developers feed known BPM and beat counts and assert decay_ms against golden fixtures without audio hardware or wall-clock timers.