Magic mile calculator
A 7:30 Magic Mile predicts about 25:01 for a 5K, 1:57:59 for a half marathon and 4:15:38 for a marathon, using Jeff Galloway's published pace multipliers for each distance. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Mile time
- 450
- Mile time formatted
- 7:30
- Five k pace
- 483
- Five k pace formatted
- 8:03
- Five k
- 1,500.61142925
The Magic Mile is a one-mile time trial used by endurance coaches, especially in Jeff Galloway programs, to predict realistic finish times from 5K through the marathon. You run one measured mile at a hard, even effort, convert that clock to seconds, and this calculator applies Galloway's published pace multipliers: add thirty-three seconds per mile for 5K, multiply by 1.15 for 10K, 1.175 for ten miles, 1.20 for the half marathon, and 1.30 for the marathon, then scale each pace across the official race distance. Mile time must be a positive number of seconds; zero, negatives, and non-numeric values fail with invalid input and are not billed.
How the Magic Mile turns a one-mile trial into race predictions
A Magic Mile is not a casual jog and not an all-out 400-metre sprint: it is one measured mile run at a hard, even effort you could not hold much farther than a football field past the finish. Coach Jeff Galloway popularized the trial after comparing hundreds of thousands of performances against that single clock, then published simple pace identities that coaches still use on the track. This landing implements those identities exactly.
Convert the trial to seconds—seven minutes thirty seconds is four hundred fifty seconds—and obtain seconds-per-mile race pace as follows: five-kilometre pace is the Magic Mile plus thirty-three seconds; ten-kilometre pace is the Magic Mile multiplied by 1.15; ten-mile pace uses 1.175; half-marathon pace uses 1.20; marathon pace uses 1.30. Finish time is that pace multiplied by official race distance in statute miles, using 1609.344 metres per international mile and IAAF lengths of 5000 m, 10000 m, 21097.5 m for the half marathon, and 42195 m for the marathon.
Ten miles is ten statute miles. The method assumes you complete the training for the target distance, race in cool weather, and pace evenly; it is a field reality check, not a laboratory VO2 test and not a promise of a personal best on a hot, hilly, or poorly paced day.
What you can do with it
Club coaching and Galloway-style programs
Coaches collect Magic Mile results every two weeks and print 5K, 10K, and marathon predictions on session cards without rebuilding the pace multipliers by hand.
FAQ
How does the Magic Mile predict 5K through marathon times?
Convert the one-mile trial to seconds. 5K pace is that time plus 33 seconds per mile; 10K pace is ×1.15; 10-mile pace is ×1.175; half-marathon pace is ×1.2; marathon pace is ×1.3. Finish time is pace times official race distance in miles.
What happens if the mile time is not a positive number?
Mile time must be a positive finite number of seconds, at most 3600. Zero, negative, and non-numeric values are rejected and not billed.
Is the magic mile calculator free?
The browser tool runs free on your device.
How is this different from a Riegel race-time predictor?
Riegel scales any known race to any other distance with a power law. The Magic Mile is a Galloway field test: one mile in, standard 5K-to-marathon clocks out, using published pace multipliers rather than (D2/D1)^1.06.
How should I run the Magic Mile?
Run one measured mile at a hard, even effort: not a casual jog and not an all-out sprint. Convert the clock to seconds, so 7:30 becomes 450, and enter it. Coaches often repeat the trial every two weeks.
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/sports/magic-mile \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mile_time":450}'const res = await fetch("https://api.kit.forhosting.com/sports/magic-mile", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mile_time": 450
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/sports/magic-mile",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mile_time": 450
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/sports/magic-mile", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mile_time":450}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mile_time":450}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/sports/magic-mile", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"mile_time": 450
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "sports.magic_mile",
"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_mile_time | 3600 |
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
How the Magic Mile turns a one-mile trial into race predictions
The arithmetic never consults a network, a clock, or a random generator, so the same mile time always yields the same JSON.
Inputs, outputs, and when the calculator rejects a request
A 7:30 mile is 450; a 10:00 mile is 600. Mile time must be a positive number—greater than zero, finite, and at most 3600 seconds (one hour) so a walking-or-slower clock cannot explode the marathon projection. Clock strings use M:SS under one hour and H:MM:SS at or above one hour, rounded to the nearest second, matching how race results are posted. Use the formatted clocks on a session card; use the second fields in spreadsheets and graders. Send a JSON body with one required finite number: mile_time, the one-mile time-trial result in seconds. The field also accepts time, seconds, mile_seconds, mm, and magic_mile. Zero, negatives, empty strings, and non-numeric text all fail with invalid_input, and those failures are not billed. On success the body echoes mile_time and mile_time_formatted as M:SS, then for each standard distance returns both the predicted finish in seconds and a clock string, plus the implied seconds-per-mile pace and its clock. Distances are five_k, ten_k, ten_mile, half_marathon, and marathon. unit_time is always seconds, method is always galloway_magic_mile, and formula restates the five pace identities so a downstream log can show the recipe next to the answer. Example: mile_time 450 (7:30) yields a 5K pace of 8:03 per mile and a 5K finish near 25:01, a 10K near 53:36, ten miles near 1:28:08, a half marathon near 1:57:59, and a marathon near 4:15:38.
Training use, API pricing, and what this number is not
Call the free in-browser magic mile calculator for track-side demos, club nights, and PE labs without rebuilding Galloway arithmetic in every spreadsheet. Use the prepaid API when a coaching SaaS, training log, or school checker needs a stable contract under KIT balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. Re-run the trial every two weeks or so, with easy days before it, and replace the stored mile_time so predicted 5K-to-marathon clocks move with fitness. Authors shipping SDKs can map marathon_formatted and five_k_formatted into dashboards and keep mile_time in seconds as the single source of truth. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when you deliberately send a zero mile time to test client validation.
Integration use cases
Marathon goal setting from a track time trial
A runner posts a hard even mile on the track, enters the time in seconds, and takes the predicted marathon and half-marathon clocks as the next training-block goal.
Training-log and race-plan backends
Apps that already store a one-mile trial call a prepaid endpoint for finish-time JSON instead of duplicating Galloway identities in every client language.
Technical questions
What unit is mile_time?
Seconds. A 7:30 mile is 450; a 10:00 mile is 600. Clock strings such as 7:30 are not parsed; send the integer or decimal second count.