Delay and reverb times calculator
At 120 BPM an eighth-note delay is 250 ms and a whole-note reverb tail is 2000 ms, with a 62.5 ms pre-delay to start. Repeats land on the beat and the wash clears on the bar line. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Bpm
- 120
- Delay note
- 1/8
- Reverb note
- 1/1
- Delay beats
- 0.5 ms
- Reverb beats
- 4
- Beat ms
- 500
- Ms per beat
- 500
A delay and reverb times calculator converts a song tempo in beats per minute plus two musical note divisions into the exact milliseconds you type into delay, echo, and reverb plugins. Mix engineers rarely want a free-running delay or an arbitrary decay; they want the repeat to land on an eighth or dotted eighth and the wash to clear on a bar line. Enter the project BPM, the delay note, and the reverb note. The tool returns the quarter-note pulse, delay time in milliseconds and seconds, delay frequency in hertz, reverb decay in milliseconds and seconds, a 1/32-note pre-delay suggestion, a closed formula, and ordered steps you can recompute by hand.
How tempo and note divisions become delay and decay times
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 twenty-eight BPM yields four hundred sixty-eight point seven five milliseconds, and sixty BPM yields one thousand milliseconds.
A tempo-synced delay multiplies that pulse by the number of beats in the chosen delay note: a straight eighth is half a beat, a dotted eighth is three quarters of a beat, a quarter-note triplet is two thirds of a beat, and a whole note in common time is four beats. A tempo-synced reverb decay uses the same pulse with a usually longer note so the tail finishes on a one-bar or two-bar phrase instead of ringing into the next section.
At one hundred twenty BPM an eighth-note delay is two hundred fifty milliseconds and a whole-note decay is two thousand milliseconds; at the same tempo a dotted-eighth delay is three hundred seventy-five milliseconds. Two bars at that tempo last four thousand milliseconds. Rejecting a non-positive BPM is essential because division by zero or a negative pulse would invent non-physical times that break session recall and MIDI automation.
What you can do with it
Match hardware multi-FX delay and decay across a live set
Live engineers compute tempo-synced delay and reverb times for several songs so a pedalboard or rack unit stays locked to the click without guessing milliseconds on stage.
FAQ
How do you calculate delay and reverb times from BPM?
Milliseconds per quarter-note beat equal 60000 divided by BPM. An eighth note is 0.5 beats; a whole note in 4/4 is 4 beats.
What happens if the tempo is zero or negative?
Tempo-synced delay and decay times are undefined when BPM is zero, negative, or missing.
What do 1/8d and 2/1 mean?
1/8d is a dotted eighth (three sixteenths, 0.75 beats). 2/1 is two whole-note bars in 4/4 (8 beats). Triplets use a t suffix, for example 1/8t is an eighth-note triplet (1/3 beat).
Is this the same as a BPM-to-milliseconds table or a reverb-beats calculator?
No. A BPM-to-milliseconds calculator returns every note value from tempo alone. A reverb-decay-from-beats tool returns one tail from a numeric beat count. This tool returns both a chosen delay and a chosen reverb decay in one response.
Is the delay and reverb times 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/delay-reverb-times \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bpm":120,"delay_note":"1/8","reverb_note":"1/1"}'const res = await fetch("https://api.kit.forhosting.com/hobby/delay-reverb-times", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bpm": 120,
"delay_note": "1/8",
"reverb_note": "1/1"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/delay-reverb-times",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bpm": 120,
"delay_note": "1/8",
"reverb_note": "1/1"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/delay-reverb-times", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bpm":120,"delay_note":"1/8","reverb_note":"1/1"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bpm":120,"delay_note":"1/8","reverb_note":"1/1"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/delay-reverb-times", 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,
"delay_note": "1/8",
"reverb_note": "1/1"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.delay_reverb_times",
"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_bpm | 1000 |
min_bpm | 1e-12 |
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 are rejected with invalid_input so automation never stores a negative or infinite time.
How to call the API and what comes back
Tempo must stay strictly greater than zero and at most one thousand BPM. The steps array walks from the raw tempo through both multiplies so you can assert intermediate values in tests. Send a JSON body with three required fields: bpm, a strictly positive finite number also accepted under the aliases tempo, beats_per_minute, and tempo_bpm; delay_note from the closed list 1/1, 1/2, 1/4, 1/8, 1/16, 1/32, 1/2d, 1/4d, 1/8d, 1/16d, 1/4t, 1/8t, 1/16t, 2/1, and 4/1; and reverb_note from the same list. Delay note also accepts delay_division, delay, and delay_div. Reverb note also accepts reverb_division, reverb, decay_note, and reverb_div. Missing fields, non-numeric tempo, non-finite values, unknown note strings, and out-of-range numbers return invalid_input and are never charged. On success the response echoes the rounded bpm and the canonical delay_note and reverb_note, sets delay_beats and reverb_beats to the quarter-note multipliers, sets beat_ms and ms_per_beat to the pulse in milliseconds, sets delay_ms, delay_seconds, and delay_hz for the echo, sets decay_ms, reverb_decay_ms, and decay_seconds for the tail, sets predelay_ms and predelay_note to the 1/32 suggestion, unit to the string ms, and formula to the closed pair of products. 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 a 1/8 delay and a 1/1 reverb is two hundred fifty milliseconds of delay and two thousand milliseconds of decay; one hundred twenty-eight BPM with a 1/8d delay and a 2/1 reverb is three hundred fifty-one point five six two five milliseconds of delay and three thousand seven hundred fifty milliseconds of decay; ninety BPM with a 1/4 delay and a 1/1 reverb is six hundred sixty-six point six recurring milliseconds of delay and two thousand six hundred sixty-six point six recurring milliseconds of decay. Prefer this capability when you already know the delay note and the reverb note and want both milliseconds in one call. 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 to demonstrate the hard invalid_input path. This landing targets people searching for delay and reverb times together, a tempo-synced delay and decay calculator, or BPM note-division milliseconds for both echo and tail; it is not a full BPM-to-milliseconds note table, not a single tail from a raw beat count, not a geometric RT60 room calculator, 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 each note's beat count, and confirm delay_ms and decay_ms within twelve-decimal rounding.
Integration use cases
Set delay and reverb on a vocal send from the session tempo
Producers enter project BPM, pick a 1/8 or 1/8d delay and a 1/1 or 2/1 reverb, then paste delay_ms and decay_ms into the two plugins so repeats and wash share one grid.
Unit tests for tempo-aware mix helpers
Developers feed known BPM and note divisions and assert delay_ms, delay_hz, and decay_ms against golden fixtures without audio hardware or wall-clock timers.