Metronome subdivision calculator
At 120 BPM a beat lasts 500 ms and each sixteenth note 125 ms, which means 8 clicks every second. Enter a tempo and a subdivision such as eighths, triplets or sixteenths to set up practice or a delay. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Tempo
- 120
- Subdivision
- 4
- Tempo bpm
- 120
- Subdivision
- 4
- Subdivision label
- sixteenth
- Beat ms
- 500
Musicians, DAW users and practice-tool builders constantly need the same conversion: at this tempo, how long is an eighth note in milliseconds, and how many subdivision clicks per second should the metronome fire? This capability answers both questions with transparent arithmetic—no audio engine, no sample buffer and no hidden swing feel. You pass a positive tempo in beats per minute and a subdivision (a positive notes-per-beat number such as 2, 3 or 4, or a name like eighth, triplet or sixteenth). The service returns the beat length in ms, the subdivision duration in ms, the click frequency in hertz and a normalized label.
What tempo and subdivision mean in milliseconds
Tempo is stated in beats per minute: one hundred twenty BPM means one hundred twenty quarter-note pulses every sixty seconds, so each beat lasts sixty thousand divided by one hundred twenty equals five hundred milliseconds. A subdivision is how many equal clicks you place inside that beat. Two means eighth notes (two equal parts per beat), three means triplets, four means sixteenth notes, and so on.
The duration of each subdivision is therefore beat length divided by that count: at one hundred twenty BPM with sixteenths you get one hundred twenty-five milliseconds per click. Frequency in hertz is the reciprocal in seconds: one thousand divided by duration in milliseconds, which simplifies to tempo times subdivision over sixty.
Where it fits in music and product workflows
Practice-app teams collect a user’s target BPM and preferred grid and need exact click intervals before scheduling Web Audio or Core Audio callbacks. DAW plugin authors convert host tempo and a subdivision menu into delay-line taps or arpeggiator steps without reimplementing float-sensitive divides that disagree on rounding. Music educators build classroom tools that show students why a triplet at ninety BPM feels different from straight eighths.
The browser path is free for single checks: enter one hundred twenty BPM and four (sixteenths) and confirm one hundred twenty-five ms and eight hertz.
What you can do with it
Practice app click grids
Convert the user’s BPM and chosen grid (eighths, triplets, sixteenths) into millisecond intervals for Web Audio scheduling.
FAQ
What does it cost?
The same calculation runs free in your browser on this page.
Why was my request rejected?
Tempo must be a positive number (greater than zero, at most 1000 BPM). Subdivision must be a positive number or a known name.
Does this generate audio?
No. It only returns timing numbers (milliseconds and hertz). Use your own click sample or oscillator with those values.
How long is a sixteenth note at 120 BPM?
125 milliseconds. Each beat lasts 500 ms at that tempo, and a sixteenth splits it into four equal clicks, so the metronome plays 8 clicks per second.
How do I work out the length of one beat in milliseconds?
Divide one minute, expressed as sixty thousand milliseconds, by the tempo. At 120 BPM that gives 500 ms per beat; then divide by the subdivision to get each click.
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/metronome-subdivision \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"tempo":120,"subdivision":"4"}'const res = await fetch("https://api.kit.forhosting.com/hobby/metronome-subdivision", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"tempo": 120,
"subdivision": "4"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/metronome-subdivision",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"tempo": 120,
"subdivision": "4"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/metronome-subdivision", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"tempo":120,"subdivision":"4"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"tempo":120,"subdivision":"4"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/metronome-subdivision", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"tempo": 120,
"subdivision": "4"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.metronome_subdivision",
"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
What tempo and subdivision mean in milliseconds
Those two numbers—duration_ms and frequency_hz—are what sequencers, LED metronomes, practice apps and MIDI clock converters need when they schedule events or drive a click track.
How to call the API and read the response
Short forms like 8th and 16th also work. There is no network hop, model call or randomness, so latency stays in the pure edge-parse band. Send two required fields: tempo as a positive number in BPM (aliases tempo_bpm, bpm and beats_per_minute are accepted) and subdivision as a positive number of notes per beat or a common name such as quarter, eighth, sixteenth, triplet, sextuplet or thirtysecond. Non-positive tempo fails immediately with invalid_input mentioning tempo and is not charged; missing or unparseable subdivision likewise raises invalid_input with a clear field name. A successful response returns tempo_bpm, the numeric subdivision used, a subdivision_label for display, beat_ms, duration_ms, frequency_hz, and unit labels for duration and frequency. Values are rounded to six decimal places so JSON stays identical across isolates and browsers. Pair the duration with your audio engine’s sample rate if you need sample offsets, or feed frequency_hz into an oscillator or LED blink driver.
Where it fits in music and product workflows
Game and interactive-installation developers sync light shows or haptic pulses to musical grids using frequency_hz as a clock. The API path costs $0.002 per successful request and is billed per item, which keeps bulk preset generators and mobile onboarding scripts cheap while still covering edge execution. Because results are deterministic, audit logs can store the full response and re-run it years later without drift, and regression suites pin exact expected JSON for every supported name and numeric subdivision.
Integration use cases
DAW and plugin timing tables
Map host tempo plus a subdivision control to delay taps, arpeggiator steps or LED blink rates with stable JSON.
Music education demos
Show students how beat length and subdivision interact by returning duration_ms and frequency_hz for side-by-side comparison.
Technical questions
How is duration_ms computed?
beat_ms = 60000 / tempo_bpm, then duration_ms = beat_ms / subdivision (notes per beat). Frequency is tempo × subdivision / 60 hertz.
Which subdivision values are accepted?
Any positive number of notes per beat, or names such as quarter, eighth, sixteenth, triplet, sextuplet and thirtysecond (plus common aliases like 8th and 16th).