BPM to milliseconds calculator
At 120 BPM a quarter note lasts 500 ms and a dotted eighth 375 ms: enter your tempo and get every note length and delay time, from whole notes to thirty-seconds, dotted and triplet. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Bpm
- 120
- Beat ms
- 500 ms
- Ms per beat
- 500
A BPM to milliseconds calculator turns a tempo in beats per minute into the exact note-value lengths and delay times you need in a DAW, pedalboard, or score. Enter the project BPM; the tool returns the quarter-note beat in milliseconds, a full table of note durations from whole notes through thirty-seconds including dotted and triplet values, and a matching delay-time map with labels such as 1/4, 1/8 dotted, and 1/8 triplet that multi-FX units and delay plugins expect. Producers syncing echoes to the grid, teachers explaining note values, and developers writing metronome or step-sequencer tests all need the same deterministic 60000 divided by BPM arithmetic without opening a spreadsheet.
How BPM becomes milliseconds for notes and delays
Beats per minute measures how many quarter-note pulses occur in sixty seconds. The reciprocal relation is simple and universal in Western production practice: milliseconds per beat equals 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. Once you have that single pulse length, every other note value is a fixed multiple of the beat.
A whole note spans four beats, a half note two, an eighth half a beat, a sixteenth a quarter of a beat, and a thirty-second an eighth of a beat. Dotted values stretch a note by half again of its undotted length, so a dotted quarter is one and a half beats and a dotted eighth is three quarters of a beat.
Triplet groups squeeze three equal notes into the span of two of the parent value, which is why a quarter-note triplet lasts two thirds of a beat and an eighth-note triplet lasts one third. Delay and multi-tap units advertise the same durations under fractional labels such as one-quarter, one-eighth dotted, or one-eighth triplet; the arithmetic is identical, only the dictionary of keys changes. Rejecting non-positive BPM is not pedantry: division by zero or a negative pulse would produce non-physical delay times that break automation scripts and hardware MIDI clocks.
What you can do with it
Sync delay and reverb times to the project grid
Producers enter session BPM and copy 1/4, 1/8_dotted, or 1/8_triplet milliseconds into plugin delay fields so echoes land on the beat.
Music theory worksheets and note-value drills
Teachers generate deterministic whole-through-thirty-second tables at a chosen tempo so students compare hand calculations against fixed ms answers.
FAQ
How do you convert BPM to milliseconds?
Milliseconds per quarter-note beat equal 60000 divided by BPM. Other note values multiply that beat duration by their relative length in beats (for example an eighth note is 0.5 beats).
What happens if BPM is zero or negative?
Delay and note durations are undefined for non-positive tempos.
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 the BPM to milliseconds calculator free?
The browser tool is free and runs locally.
What delay time is a dotted eighth at 120 BPM?
A dotted eighth lasts 375 ms at 120 BPM, because it is three quarters of a 500 ms beat. Set your delay to that value and the echoes fall between the beats with the classic dotted feel.
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/bpm-to-ms \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bpm":120}'const res = await fetch("https://api.kit.forhosting.com/hobby/bpm-to-ms", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bpm": 120
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/bpm-to-ms",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bpm": 120
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/bpm-to-ms", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bpm":120}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bpm":120}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/bpm-to-ms", 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
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.bpm_to_ms",
"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_abs | 1000000000000 |
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 a clear invalid_input error so scripts never silently invent negative or infinite delay times.
How to call the API and what comes back
The steps array walks from the raw tempo through the beat duration and representative note and delay rows so you can assert intermediate values in tests. Send a JSON body with one required finite number: bpm, also accepted under the aliases tempo, beats_per_minute, and tempo_bpm. Absolute value must stay within the published limit of one trillion, and the value must be strictly greater than zero; values at or below zero, missing fields, non-numeric strings, and non-finite numbers return invalid_input and are never charged. On success the response echoes the rounded bpm, sets beat_ms and ms_per_beat to the same quarter-note duration in milliseconds, unit to the string ms, formula to the closed relation duration_ms equals 60000 over bpm times note_beats with one beat equal to a quarter note, and message to a short English summary. The object note_durations_ms lists whole, half, quarter, eighth, sixteenth, thirty_second, dotted_half, dotted_quarter, dotted_eighth, dotted_sixteenth, triplet_quarter, triplet_eighth, and triplet_sixteenth. The object delay_times_ms lists the same physics under production labels including 1/1, 1/2, 1/4, 1/8, 1/16, 1/32, dotted and triplet variants such as 1/4_dotted and 1/8_triplet. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
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 means five hundred milliseconds on the quarter, two hundred fifty on the eighth, and one hundred twenty-five on the sixteenth; seventy-two BPM is useful for ballad delay checks; one hundred forty BPM is a frequent electronic dance baseline. Prefer this capability when you already know the project tempo and only need millisecond tables; if your source is a free-time recording without a grid, detect or tap BPM first. Keep BPM inside the published absolute 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, and confirm that dotted and triplet keys stay consistent with the undotted parent multiplied by one point five or by two thirds respectively. This landing targets people searching for a BPM to milliseconds calculator, tempo note duration converter, or delay time in ms from beats per minute; it is not a swing or shuffle feel engine, not a sample-rate or MIDI ticks-per-quarter converter, and not a real-time metronome audio generator. 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 60000 divided by bpm and confirm it equals beat_ms within twelve-decimal rounding, then multiply by the documented beat counts for whole, dotted quarter, and triplet eighth rows.
Integration use cases
Unit tests for sequencers and metronomes
Developers feed known BPM values and assert beat_ms plus note_durations_ms against golden fixtures without wall-clock timers or audio hardware.
Technical questions
What is the difference between note_durations_ms and delay_times_ms?
They use the same millisecond values. note_durations_ms uses music names (quarter, dotted_eighth); delay_times_ms uses DAW-style labels (1/4, 1/8_dotted) common on delay plugins.