Swim stroke rate calculator
Divide your stroke count by the seconds it took and multiply by 60 to get strokes per minute: 40 strokes in 60 seconds, or 30 in 45, is 40 SPM, one stroke every 1.5 seconds. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Strokes
- 40
- Time seconds
- 60
- Stroke rate spm
- 40
- Seconds per stroke
- 1.5
- Strokes per second
- 0.6666666667
A swim stroke rate calculator turns how many strokes you took and how long that segment lasted into the cadence number coaches and wearables quote every day: strokes per minute, often written SPM. Enter the stroke count for a length, a timed set, or a race segment, the elapsed time in total seconds, and the tool returns stroke rate in SPM, seconds per stroke, strokes per second, a short formula, a one-line message, and step-by-step arithmetic you can audit.
What swimming stroke rate means and how SPM is computed
Swimming stroke rate is cadence: how many arm cycles (or bilateral stroke counts, depending on how you count) you complete in one minute at a steady effort. Coaches use SPM together with distance per stroke and pace so freestyle, backstroke, breaststroke, and butterfly sets can be compared without guessing from feel alone. The definition used here is straightforward and universal: stroke rate in strokes per minute equals stroke count divided by elapsed time in seconds, then multiplied by sixty.
If you take forty strokes in sixty seconds, your rate is forty SPM. If you take thirty strokes in forty-five seconds, the same formula yields forty SPM as well, because thirty over forty-five times sixty is forty. The reciprocal view is seconds per stroke: elapsed time divided by stroke count, which tempo trainers and drill cards often prefer when they say “one stroke every one point five seconds.”
Strokes per second is the unscaled intermediate (count over time) before multiplying by sixty. Zero or negative inputs fail loudly: a zero time would make rate infinite, and a zero stroke count is not a measured cadence interval.
Practical tips, limits, and related searches
Prefer a whole length or a multi-length set with a stopwatch so short noisy samples do not dominate the rate. Convert wall-clock times to total seconds before you call: ninety seconds for one minute thirty, not a formatted string. Keep strokes and time inside the published maxima; efforts longer than one hundred days or counts above one million are rejected as out of range rather than returning nonsense.
Pair this calculator with pace and distance tools when you also need speed: stroke rate alone does not say how far each stroke travels, so SWOLF-style efficiency metrics need distance or split pace from another source. This landing targets people searching for a swim stroke rate calculator, strokes per minute, swimming cadence, or SPM from stroke count and time; it is not a swimming pace calculator, not a calorie estimator, and not a video stroke detector.
Prefer this capability when you already know count and elapsed seconds and only need SPM and seconds per stroke.
What you can do with it
Technique sets with target SPM
Coaches prescribe a cadence band for a freestyle set; athletes count strokes and stopwatch the interval, then convert to SPM to confirm they hit the band.
Wearable and log normalization
Apps store raw stroke counts and segment durations from any pool session, then call this tool once to fill a consistent strokes-per-minute column for charts.
Tempo trainer cross-checks
Compare a beeper set to measured seconds per stroke and SPM after a timed length so drill feedback matches the calculator, not a guess.
FAQ
How is swimming stroke rate calculated?
Stroke rate in strokes per minute (SPM) equals stroke count divided by elapsed time in seconds, then multiplied by 60. This tool also returns seconds per stroke and strokes per second.
What happens if strokes or time is zero or negative?
Stroke rate is undefined for non-positive time, and a non-positive stroke count is not a valid measured interval.
Is the swim stroke rate calculator free?
The browser tool is free and runs locally.
Should I count each arm or each full stroke cycle?
Either works, as long as you always count the same way. Some coaches count every arm entry in freestyle as one stroke, others count full cycles, and the two methods give different rates for the same swim.
Does stroke rate show how efficient my stroke is?
Not on its own. It tells you how often you stroke, not how far each stroke carries you. For efficiency you also need distance per stroke or your pace over the same length.
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/health/swim-stroke-rate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"strokes":40,"time_seconds":60}'const res = await fetch("https://api.kit.forhosting.com/health/swim-stroke-rate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"strokes": 40,
"time_seconds": 60
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/swim-stroke-rate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"strokes": 40,
"time_seconds": 60
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/swim-stroke-rate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"strokes":40,"time_seconds":60}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"strokes":40,"time_seconds":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/swim-stroke-rate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"strokes": 40,
"time_seconds": 60
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.swim_stroke_rate",
"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-positive stroke counts or times are rejected with a clear invalid_input error so bad form data never looks like an elite cadence.
How to call the API and what comes back
Fractional stroke counts are accepted when your counter exports partial cycles; whole numbers are the usual case for pool lengths. Do not send clock strings such as one colon zero zero for time; convert to total seconds first (sixty for one minute, one hundred twenty for two minutes). Send a JSON body with two required finite positive numbers: strokes (aliases stroke_count, stroke_count_total, count, n, num_strokes) and time_seconds (aliases time, elapsed, elapsed_seconds, duration, duration_seconds, t, seconds). Strokes must stay within one million and time within eight million six hundred forty thousand seconds so intermediate products remain finite on the Worker and in the browser. On success the response echoes rounded strokes and time_seconds; returns stroke_rate_spm as the primary strokes-per-minute value; adds seconds_per_stroke and strokes_per_second; includes formula, message, and an ordered steps array showing the division and the sixty-second scale. Failed validation—missing fields, non-finite numbers, non-positive strokes or time, or values outside published limits—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item.
Practical tips, limits, and related searches
Count strokes the same way every time before you call the API: some coaches count each arm entry as one stroke in freestyle, while others count full cycles; pick one convention and stick to it so SPM trends mean something week to week. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately send a zero count to test client validation.
Technical questions
What inputs do I need?
Two finite positive numbers: strokes (how many strokes you counted) and time_seconds (how long that interval lasted in total seconds).
Do I send time as MM:SS?
No. Send total elapsed time as time_seconds (for example 60 for one minute). Convert clock times to seconds before calling.