Stopwatch split times
Paste the cumulative stopwatch marks and get each lap's own duration: three splits ending at 100 seconds become laps of 30, 35 and 35. You also see the total, the fastest and slowest lap and the average. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Splits
- 30, 65, 100
- Total
- 100
- Quantity
- 3
- Start
- 0
- Durations
- 30, 35, 35
Coaches, timing boards, and training apps need the opposite view—how long each segment actually took—so they can rank intervals, compare efforts, and chart pace without a spreadsheet. This stopwatch split times tool accepts an ordered list of cumulative timestamps plus an optional start offset, subtracts successive values, and returns every lap duration together with total time, fastest and slowest lap, and the average. The algorithm is pure arithmetic on your numbers: it never reads the system clock, never invents missing marks, and rejects decreasing sequences so a typo cannot become a negative lap.
From cumulative splits to lap durations
A cumulative split is the total elapsed time from a fixed origin—usually the gun or the moment the stopwatch started—to the instant that split is recorded. The first lap duration is the first mark minus the start offset (zero when the list begins at the gun). Every later lap is the difference between that mark and the previous one, so the sequence becomes thirty, thirty-five, and thirty-five seconds.
This stopwatch split times calculator applies that differencing pass exactly once, in list order, and never re-sorts or re-times the marks against a live clock. Optional start covers the case where the first mark is not relative to zero—for example when a partial interval begins at an intermediate board reading.
Where lap duration conversion earns its keep
Track and swim coaches paste board splits after a set and need lap-by-lap duration without rebuilding a spreadsheet for every heat. Running clubs and triathlon clubs export cumulative GPS or manual stopwatch marks and want fastest and slowest interval flags for feedback messages. Classroom physics labs that teach constant-speed intervals can grade student stopwatch tables against a deterministic oracle.
Keep lists under the documented maximum, pin rounded durations in tests, and you get reproducible lap tables for coaching apps, LMS plugins, and edge workers without standing up a clock service of your own.
What you can do with it
Coaching and heat sheets
Paste cumulative board splits after a set and receive each lap duration plus fastest and slowest lap indices for immediate feedback.
Training app exports
Convert GPS or stopwatch cumulative marks into ordered lap durations before storing pace series or charting interval effort.
Classroom timing labs
Grade student stopwatch tables with a deterministic oracle that rejects decreasing marks and never uses the server clock.
FAQ
How do I convert cumulative stopwatch splits into lap times?
Send splits as an ordered list of cumulative timestamps. Lap 1 is the first mark minus start (default 0); each later lap is the difference from the previous mark.
What units should I use for the timestamps?
Any consistent numeric unit works—seconds, milliseconds, or minutes. The calculator only differences your numbers and returns durations in the same unit you supplied.
What if my splits go backwards?
A later mark smaller than the previous one is invalid for cumulative series.
What does the result show besides each lap time?
The total time, the fastest and slowest lap with their position, and the average lap. For three marks ending at 100 seconds, lap 1 is the fastest at 30 and lap 2 the slowest at 35.
Can I start counting from a time other than zero?
Yes. Enter a start time and the first lap becomes the first mark minus that start. It cannot be greater than the first mark, and it counts as zero when left empty.
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/date/stopwatch-split-times \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"splits":[30,65,100]}'const res = await fetch("https://api.kit.forhosting.com/date/stopwatch-split-times", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"splits": [
30,
65,
100
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/stopwatch-split-times",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"splits": [
30,
65,
100
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/stopwatch-split-times", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"splits":[30,65,100]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"splits":[30,65,100]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/stopwatch-split-times", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"splits": [
30,
65,
100
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.stopwatch_split_times",
"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
Stopwatch split times are almost always written as cumulative marks: the clock reading when each split button is pressed, not the length of that individual lap.
From cumulative splits to lap durations
Because units cancel in successive subtraction, you may send seconds, tenths, milliseconds, or any other consistent numeric scale; the endpoint returns durations in the same unit you supplied. If any later timestamp is smaller than the one before it, the list is not a valid cumulative series and the request fails with invalid_input rather than fabricating a negative duration that would break pace charts and auto-graders.
Input contract, response fields, and validation
Each value must be non-negative. The sequence must be non-decreasing: equal consecutive marks mean a zero-length lap, which is accepted for completeness when two presses land on the same reading. Optional start defaults to zero and must itself be non-negative and not greater than the first split. All numeric outputs are rounded to twelve decimal places so goldens and SDKs stay stable across runtimes. POST a JSON body with splits as a non-empty array of finite numbers, or as a comma, space, or semicolon separated string for text forms. Aliases times, timestamps, cumulative, and marks map to splits; offset, t0, and begin map to start. On success the body echoes the normalized start and rounded splits, then returns count, durations as an array of lap lengths in list order, total as the last split minus start, fastest_duration and slowest_duration, one-based fastest_lap and slowest_lap indices (first occurrence wins on ties), and average_duration. Empty lists, missing splits, non-finite values, negative marks, a start past the first mark, and decreasing sequences raise invalid_input and are not billed. The free browser path uses the identical pure module as the API, so classroom demos and production automations never disagree on the same inputs.
Where lap duration conversion earns its keep
Fitness content sites that rank for stopwatch split times or lap duration calculator gain a live tool whose answers match the prepaid automation path byte for byte. Sports data pipelines convert vendor cumulative timestamps into per-segment durations before storing pace series; a tiny parse API avoids pulling a full timing stack for a linear difference.
Technical questions
Can I set a non-zero start offset?
Yes. Optional start (aliases offset, t0, begin) is the cumulative time at the beginning of the first lap. It must be non-negative and not greater than the first split.
What does the stopwatch split times calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.