Pace to speed converter
A pace of 5:30 per kilometre is just under 11 km/h, the number to set on a treadmill. Type your pace per kilometre or per mile and get the matching speed in both km/h and mph. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Pace
- 5:30 km
- Pace minutes
- 5.5 km
- Pace display
- 5:30
- Unit label
- min/km
- Speed kmh
- 10.909091
This pace to speed converter turns a running pace — the time you take to cover one kilometre or one mile — into the equivalent constant speed in kilometres per hour and miles per hour. Runners, coaches, and training apps often log splits as five thirty per kilometre or eight minutes per mile, while treadmills, bike computers, and race charts speak in km/h or mph; bridging those units without a spreadsheet error is exactly what this page does. The identities are closed form and fully deterministic: when pace is minutes per kilometre, speed in km/h equals sixty divided by that pace, and mph follows by dividing by the exact international mile of 1.609344 kilometres; when pace is minutes per mile, mph is sixty over pace and km/h multiplies by the same mile factor. Zero or negative pace is rejected because it cannot map to a finite speed. The engine uses only finite arithmetic with no network calls, no sampling, and no date-dependent shortcuts.
Where pace-to-speed conversion fits in training, racing, and software
Athletes meet pace charts when a coach assigns easy kilometres at five forty-five, when a treadmill shows speed instead of pace, or when a race plan mixes kilometre splits with mile markers on an overseas course. Coaches can pre-generate speed tables for modest paces without trusting opaque apps that silently switch between statute and nautical miles or drop the colon in clock notation.
Developers call the same contract from scripts to seed deterministic test vectors for training dashboards, to normalize user-entered pace before plotting speed trends, or to satisfy programming-challenge statements that demand both km/h and mph from a single split. Race directors and event apps use the conversion when a participant types a goal pace and the UI must show the matching constant speed for course vehicles and timing boards. Pair it with unit converters or other health helpers when you are building a small lab of free, deterministic sports utilities.
What you can do with it
Training pace charts
Convert coach-assigned min/km or min/mi splits into km/h and mph for treadmills, bike computers, and pace boards.
Race and app UIs
Normalize user-entered pace strings into both metric and imperial speeds for dashboards, timing boards, and SDKs.
FAQ
What does the pace to speed converter cost?
It is free in your browser on this page.
How is speed calculated from pace?
For a positive pace in minutes per unit, speed in that unit's per-hour measure is 60 divided by the pace.
What happens if pace is zero or negative?
Zero or negative pace cannot convert to a finite speed.
Can I enter pace as 5:30 instead of decimal minutes?
Yes. The pace field accepts M:SS, MM:SS, or H:MM:SS clock forms, or a decimal number of minutes. You can also send minutes and optional seconds as separate fields.
Can I convert a pace given per mile?
Yes. Choose per mile and the speed in mph is 60 divided by your pace in minutes. The km/h figure then multiplies that by 1.609344, the exact number of kilometres in an international mile.
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/pace-to-speed \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pace":"5:30"}'const res = await fetch("https://api.kit.forhosting.com/health/pace-to-speed", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pace": "5:30"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/pace-to-speed",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pace": "5:30"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/pace-to-speed", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pace":"5:30"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pace":"5:30"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/pace-to-speed", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"pace": "5:30"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.pace_to_speed",
"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_pace_minutes | 1000000 |
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 pace means and what the converter returns
Running pace is the time required to cover a fixed distance, almost always one kilometre or one statute mile. It is the reciprocal view of speed: a slower pace (more minutes per unit distance) means a lower speed, and a faster pace means a higher speed. This converter accepts pace as a clock-style string such as five thirty (written 5:30), as decimal minutes such as 5.5, or as separate minutes and seconds fields, and it asks whether that pace is per kilometre or per mile. From a positive pace it returns pace_minutes as a decimal, a pace_display string rounded to whole seconds, the normalized unit km or mi with a unit_label of min/km or min/mi, speed_kmh, speed_mph, the precision used, a short formula string, and the method tag pace_to_speed. There is no approximate GPS path and no random sampling of splits: the engine either builds exact floating-point speeds inside the supported range or rejects the input with invalid_input. Rejected cases include missing pace and minutes, non-finite values, magnitudes above the documented ceiling, and any pace that is zero or negative, because division by a non-positive pace cannot yield a finite speed.
How pace and unit are read and how speeds stay reproducible
The preferred field is pace for a single value — either a decimal number of minutes or a colon-separated clock form M:SS, MM:SS, or H:MM:SS — with aliases p, time, and min_per so spreadsheets and query strings can reuse the same contract. Alternatively you may send minutes plus optional seconds (aliases min and m for minutes, sec and s for seconds); do not send both pace and minutes in the same request. The unit field defaults to km and accepts km, mi, mile, miles, kilometer, kilometers, per_km, per_mi, min/km, and min/mi so forms and SDKs can speak either sporting dialect. Optional precision, with aliases decimals and dp, chooses how many decimal places to expose for pace_minutes, speed_kmh, and speed_mph, defaulting to six and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing mile conversion constants yourself.
Where pace-to-speed conversion fits in training, racing, and software
Product and health tools use it when a wearable exports min per kilometre and a partner API expects mph. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a track-side check to an automated pipeline without changing the numerical result.
Integration use cases
Deterministic test fixtures
Generate reproducible speed_kmh and speed_mph values for unit tests, CI assertions, and wearable pipeline checks.
Technical questions
Is the mile the international statute mile?
Yes. Conversions use 1 mile = 1.609344 kilometres, the exact international definition used in road racing and most consumer GPS units.