BPM from tap intervals calculator
Taps at 0, 500, 1000 and 1500 ms leave three gaps of 500 ms, which is a tempo of 120 BPM. Enter the moments you tapped along to a groove and get a tempo you can set in your project. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Taps
- 0, 500, 1,000, 1,500
- Taps ms
- 0, 500, 1,000, 1,500 bpm
- Tap count
- 4
- Intervals ms
- 500, 500, 500
- Interval count
- 3
A BPM from tap intervals calculator turns a sequence of user-entered tap timestamps into a single, reproducible tempo in beats per minute. You supply at least two ordered times in milliseconds—relative offsets from the first tap or absolute clock values—and the tool measures every consecutive interval, averages those positive gaps, and converts the mean spacing with the classic studio relation BPM equals sixty thousand divided by mean milliseconds per beat. Producers who hear a groove but have no project tempo, teachers demonstrating tap-tempo workflow, and developers writing metronome or sequencer tests all need the same deterministic arithmetic without opening a spreadsheet or guessing from a stopwatch.
How tap timestamps become beats per minute
Tap tempo estimation starts from the observation that a steady beat produces nearly equal time gaps between successive hits. If you record the moment of each tap in milliseconds and require the sequence to be strictly increasing, every consecutive difference is a positive interval that represents one beat period under the assumption that you tapped once per beat. Averaging those intervals smooths small human timing errors: a single late or early tap shifts only one or two gaps, while the mean of many intervals converges toward the intended pulse.
Converting the mean interval into beats per minute uses the same reciprocal used throughout music production: there are sixty thousand milliseconds in a minute, so dividing that constant by the average milliseconds per beat yields how many quarter-note pulses would occur if the mean spacing held for a full minute. For example, four taps at zero, five hundred, one thousand, and fifteen hundred milliseconds produce three equal five-hundred-millisecond intervals and a mean of five hundred, which maps to one hundred twenty BPM—the familiar house and pop grid.
Uneven live tapping still works: intervals of four hundred eighty, five hundred twenty, and five hundred milliseconds average five hundred and still report one hundred twenty BPM after rounding. Rejecting non-positive intervals is essential; a zero gap would imply infinite tempo, and a negative gap would mean the timestamps were out of order.
Practical tips, limits, and related searches
Tap at least four to eight times when you can: more intervals reduce the influence of any single mistimed hit, though two timestamps already define a single-interval tempo for scripted tests. Common studio checkpoints are easy to verify by hand: five hundred milliseconds mean spacing is one hundred twenty BPM, six hundred milliseconds is one hundred BPM, and four hundred twenty-eight point five seven milliseconds is about one hundred forty BPM. Prefer this capability when your source is human or programmatic taps without a pre-existing grid.
Round-trip checks are straightforward: recompute each consecutive difference, average them, divide sixty thousand by that mean, and confirm the result equals the published bpm within twelve-decimal rounding.
What you can do with it
Guess session tempo from a tapped groove
Producers tap along to a reference track or live take, paste the millisecond timestamps, and set the DAW project BPM from the returned average tempo.
FAQ
How do you calculate BPM from tap timestamps?
Measure each consecutive positive interval in milliseconds, average those intervals, then compute BPM as 60000 divided by the mean interval. One average beat period maps to how many beats fit in a minute.
How many taps do I need?
At least two timestamps (one positive interval). More taps improve stability because the mean smooths single-tap timing errors.
What if my taps are not strictly increasing?
Any zero or negative interval means the sequence is out of order or duplicated.
Are absolute clock times required, or can I start at zero?
Either works. Only differences between consecutive timestamps matter, so relative offsets starting at 0 are equivalent to absolute epoch milliseconds.
Is the BPM from tap intervals 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-bpm-from-tap \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"taps":[0,500,1000,1500]}'const res = await fetch("https://api.kit.forhosting.com/hobby/music-bpm-from-tap", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"taps": [
0,
500,
1000,
1500
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/music-bpm-from-tap",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"taps": [
0,
500,
1000,
1500
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/music-bpm-from-tap", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"taps":[0,500,1000,1500]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"taps":[0,500,1000,1500]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/music-bpm-from-tap", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"taps": [
0,
500,
1000,
1500
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.music_bpm_from_tap",
"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-monotonic or incomplete sequences are rejected with a clear invalid_input error so scripts never invent a tempo from a single click or a reverse-ordered list.
How to call the API and what comes back
The array must contain at least two and at most five hundred finite numbers. 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. Relative clocks that start at zero are fine, and absolute epoch-style milliseconds are equally fine, because only the differences enter the mean. Send a JSON body with one required array field named taps, also accepted under the aliases timestamps, tap_times, times_ms, and tap_timestamps. Absolute value of each timestamp stays within the published limit so differences remain well-defined in IEEE double precision. On success the response echoes the rounded taps_ms sequence, tap_count, the intervals_ms list of consecutive positive deltas, interval_count, mean_interval_ms and the synonym beat_ms for the average spacing, bpm as the estimated tempo, unit set to the string bpm, formula stating bpm equals 60000 over the mean of consecutive positive intervals, message as a short English summary, and steps that walk from the raw timestamps through each interval, the mean, and the final division. Missing arrays, non-array values, fewer than two timestamps, non-finite entries, empty strings that fail numeric coercion, and any non-positive interval between consecutive taps return invalid_input and are never charged. Pricing is a flat $0.002 per successful request with unit item.
Practical tips, limits, and related searches
Keep the sequence strictly increasing; if your capture layer can emit duplicate timestamps under high load, deduplicate or add a tiny offset before calling the API. When teaching, pair a steady happy-path sequence with a deliberate single-tap or reverse-order error case so learners see invalid_input immediately. This landing targets people searching for a BPM from tap calculator, tap tempo from intervals, or beats per minute from tap timestamps; it is not an audio onset detector, not a swing quantizer, and not a BPM-to-milliseconds note table—for known project tempo converted into note and delay durations use the sibling BPM to milliseconds calculator instead. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately probe edge cases.
Integration use cases
Classroom tap-tempo and reciprocal drills
Teachers give ordered tap lists so students recompute mean interval and 60000/mean by hand, then match the deterministic BPM field in the API response.
Unit tests for metronomes and sequencers
Developers feed fixed synthetic tap arrays and assert bpm, mean_interval_ms, and intervals_ms against golden fixtures without audio hardware or wall-clock timers.