BPM calculator
Eight beats counted in four seconds is 120 BPM: enter the beats you counted and the seconds on your stopwatch to get the tempo and the length of one beat, 0.5 s or 500 ms here. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Beats
- 8
- Interval
- 4
- Bpm
- 120 bpm
- Beat seconds
- 0.5
- Beat ms
- 500
A BPM calculator turns a counted number of beats and a measured time interval in seconds into tempo in beats per minute. Musicians, DJs, teachers, and coaches still use the stopwatch method: count pulses over a known window, then scale that rate to one minute with the identity BPM equals beats times sixty divided by interval. This tool applies that formula with strict checks that both values are finite and strictly positive.
How counted beats and a stopwatch become beats per minute
The stopwatch method for tempo is older than tap pads and digital audio workstation buttons: you count how many beats occur while a clock runs, then scale that count to a full minute. If eight pulses fall inside four seconds, the implied rate is eight over four beats per second, which is one hundred twenty beats per minute. The identity is therefore BPM equals beats times sixty divided by the interval in seconds.
Both operands must be strictly positive finite numbers. A zero or negative beat count would describe no pulse or a reverse-time fantasy; a zero or negative interval would describe no window or a reversed clock, and the quotient would be undefined or infinite. This capability coerces the two fields, rejects missing values, empty strings, NaN, infinities, and non-positive amounts, then publishes the tempo together with seconds per beat and milliseconds per beat so a metronome, delay, or lesson plan can consume a single consistent pulse.
Count a longer window when the groove is uneven; more beats over more seconds reduce the effect of a single early or late hit on the reported tempo.
Practical counting, limits, and related searches
Count at least four to eight beats when you can: a one-beat sample over a tiny window is mathematically valid but noisy in live playing. Keep the clock honest; starting the stopwatch on beat one versus beat zero is a common off-by-one that shifts tempo by a whole step if you mis-count.
Common studio checkpoints are easy to verify by hand: eight beats in four seconds is one hundred twenty BPM, four beats in two seconds is the same grid, and thirty-two beats in fifteen seconds is one hundred twenty-eight BPM. For ordered tap timestamps use the sibling BPM from tap intervals calculator; for a known project tempo converted into note and delay durations use the sibling BPM to milliseconds calculator. Prefer this capability when your source is a counted total against a measured window.
Round-trip checks are straightforward: multiply beats by sixty, divide by the interval in seconds, and confirm the result equals the published bpm within twelve-decimal rounding.
What you can do with it
Set session tempo from a stopwatch count
Producers count beats along a reference track for four or eight seconds, enter the total and the window, and set the DAW project BPM from the returned tempo.
Classroom reciprocal and 15-second drills
Teachers give beat counts and intervals so students recompute beats × 60 / seconds by hand, including the classic fifteen-second count multiplied by four, then match the deterministic BPM field.
FAQ
How do you calculate BPM from counted beats and seconds?
Divide the number of beats by the measured interval in seconds to get beats per second, then multiply by sixty. Equivalently, BPM equals beats times sixty divided by interval.
What happens if beats or interval is zero or negative?
A non-positive count or window cannot define a finite tempo, and the tool will not invent one.
Do I send tap timestamps or a beat count?
Send a beat count and an interval in seconds. For ordered tap timestamps in milliseconds, use the sibling BPM from tap intervals calculator instead.
Why does a 15-second count get multiplied by four?
There are four fifteen-second blocks in a minute, so count × 4 equals count × 60 / 15. This calculator uses the general form so any window length works, not only fifteen seconds.
Is the 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/bpm \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"beats":8,"interval":4}'const res = await fetch("https://api.kit.forhosting.com/hobby/bpm", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"beats": 8,
"interval": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/bpm",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"beats": 8,
"interval": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/bpm", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"beats":8,"interval":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"beats":8,"interval":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/bpm", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"beats": 8,
"interval": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.bpm",
"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_positive | 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
Zero beats, a zero-length window, missing fields, and non-numeric strings are rejected as invalid_input so scripts never invent an infinite tempo.
How counted beats and a stopwatch become beats per minute
Rounding is fixed to twelve decimal places so Worker and browser JSON match byte for byte on the same inputs. Classroom drills still use the fifteen-second count: sixteen beats in fifteen seconds is sixty-four BPM, and thirty-two beats in fifteen seconds is one hundred twenty-eight BPM, because multiplying the fifteen-second count by four is the same as multiplying by sixty and dividing by fifteen.
How to call the API and what comes back
Beats is the counted total; interval is the measured window in seconds. Prefer sending numbers rather than pre-formatted strings when you control the client. Relative windows such as four seconds of counting are the intended case; you do not send timestamps here. Send a JSON body with two required number fields named beats and interval. The same values are accepted under the aliases count, beat_count, and n_beats for the first field, and seconds, time, duration, and t for the second. Each field may arrive as a JSON number or as a strict numeric string. On success the response echoes the rounded beats and interval, returns bpm as the primary tempo, beat_seconds and beat_ms as the duration of one pulse, unit set to the string bpm, formula restating bpm equals beats times sixty divided by interval, message as a short English summary, and steps that walk from the raw count through seconds per beat to the final division. Missing fields, non-finite entries, empty strings that fail numeric coercion, and any non-positive beats or interval return invalid_input and are never charged. Pricing is a flat $0.002 per successful request with unit item. Absolute magnitude of each operand stays within the published limit so the quotient remains well-defined in IEEE double precision.
Practical counting, limits, and related searches
When teaching, pair a happy-path count with a deliberate zero or negative input so learners see invalid_input immediately. This landing targets people searching for a BPM calculator, beats per minute from counted beats, or tempo from beats and seconds; it is not a tap-tempo pad that averages millisecond timestamps, not a BPM-to-milliseconds note table, and not an audio onset detector. 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
Pulse or click-track checks in scripts
Developers and coaches feed a counted total and a measured window and assert bpm, beat_seconds, and beat_ms against golden fixtures without audio hardware or wall-clock timers.