Keystrokes per hour calculator
3,000 keystrokes in 10 minutes is 300 a minute, or 18,000 keystrokes per hour. Enter the key count from your typing log and the elapsed minutes of the same session to get the KPH figure that transcription, coding and data-entry reports quote. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Keystrokes
- 3,000
- Minutes
- 10
- Hours
- 0.1666666667
- Keystrokes per minute
- 300
- Keystrokes per hour
- 18,000
A keystrokes-per-hour calculator turns a raw typing log into the speed figure many transcription, medical-coding, court-reporting, data-entry, and accessibility reports still quote: keystrokes per hour, often abbreviated KPH. Enter the total keystrokes counted in a session and the elapsed minutes for that same session, and the tool returns the hourly rate by dividing keystrokes by minutes and multiplying by sixty. Zero keystrokes in a positive duration is a valid idle result of zero KPH. A negative keystroke count is rejected, and a zero elapsed-minute value is rejected because the hourly rate would be undefined.
What keystrokes per hour means and how KPH is computed
Keystrokes per hour, often abbreviated KPH, is a typing-speed unit used in transcription, medical coding, court reporting, data-entry staffing, and accessibility testing. Unlike words per minute, which depends on an assumed average word length, KPH counts every key event the operator actually produced: letters, digits, spaces, punctuation, and usually backspaces if the logger recorded them.
The definition used here is the same scale conversion every supervisor already does on a whiteboard: divide the total keystroke count by the elapsed minutes of the measured interval, then multiply by sixty to raise the per-minute rate to an hourly rate. Three thousand keystrokes in ten minutes is three hundred keystrokes per minute and eighteen thousand keystrokes per hour.
One thousand two hundred thirty-four keystrokes in seven and a half minutes is one hundred sixty-four point five three repeating keystrokes per minute and nine thousand eight hundred seventy-two keystrokes per hour. Zero keystrokes over a positive duration is a legitimate idle sample and returns zero KPH, not an error. A negative count is not a physical session and is rejected.
What you enter and what you get back
Keystrokes must be non-negative; minutes must be a non-zero duration. Embedded spaces, hex prefixes, and non-numeric tokens fail with a message that names the field. Example: three thousand keystrokes in ten minutes yields eighteen thousand KPH and three hundred keystrokes per minute.
A negative keystroke count is rejected with a clear message that typing speed is undefined for a negative count. Elapsed minutes of zero is rejected because the hourly rate is undefined. Failed validation is never charged.
Do not send clock strings such as one colon zero zero for minutes; convert to a decimal minute count first.
Where a keystrokes-per-hour calculator earns its keep
People reach for a keystrokes-per-hour calculator whenever a logger already stored a raw count and a stopwatch already stored elapsed minutes, and a human or a script still needs the hourly staffing figure. Transcription shops convert a session of eight thousand keystrokes in twenty-four minutes into twenty thousand KPH before they compare operators on a common scale. Medical-coding and court-reporting trainers assign the conversion so students practice scaling a per-minute rate to an hour instead of guessing.
Accessibility labs measure how many keystrokes a switch or on-screen keyboard produced in a timed trial and need KPH next to words-per-minute so reports stay honest about what was counted. Because the tool rejects a negative count and a zero duration, it also doubles as a validator for intake forms that must not accept minus two hundred keys or a blank timer.
Pair this page with a word counter if you also need words per minute from prose, with a unit-rate tool if you have a generic total over a count, or with a swim stroke-rate calculator if the cadence you want is strokes per minute, not keystrokes per hour.
What you can do with it
Transcription and data-entry staffing
Convert a logged keystroke count and a stopwatch interval into KPH so operators are compared on the same hourly scale instead of raw session totals.
Accessibility and switch-access trials
Measure how many keystrokes a switch, on-screen keyboard, or alternative input produced in a timed trial and report keystrokes per hour next to other speed figures.
FAQ
How is keystrokes per hour calculated?
Keystrokes per hour (KPH) equals total keystrokes divided by elapsed minutes, then multiplied by 60. This tool also returns hours and keystrokes per minute.
What inputs do I need?
Two finite numbers: keystrokes (non-negative total count) and minutes (elapsed duration, not zero). Fractional minutes such as 7.5 are accepted.
What happens if keystrokes are negative?
A negative keystroke count is not a physical typing session, so typing speed is undefined.
What happens if elapsed minutes are zero?
Dividing by zero minutes would make the hourly rate undefined.
Is the keystrokes per hour 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/life/keystrokes-per-hour \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"keystrokes":3000,"minutes":10}'const res = await fetch("https://api.kit.forhosting.com/life/keystrokes-per-hour", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"keystrokes": 3000,
"minutes": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/keystrokes-per-hour",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"keystrokes": 3000,
"minutes": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/keystrokes-per-hour", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"keystrokes":3000,"minutes":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"keystrokes":3000,"minutes":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/keystrokes-per-hour", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"keystrokes": 3000,
"minutes": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.keystrokes_per_hour",
"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
Successful API requests cost $0.002.
What keystrokes per hour means and how KPH is computed
Elapsed minutes of exactly zero would make the quotient infinite, so that case is rejected as invalid_input instead of returning Infinity.
How to call the API and what comes back
Send a JSON body with two required finite numbers: keystrokes (aliases keys, keystroke_count, total_keystrokes, n) and minutes (aliases elapsed_minutes, time_minutes, duration_minutes, mins, t). Each field may arrive as a JSON number or as a decimal numeric string, including an optional leading plus and scientific notation. Missing fields, empty strings, Infinity, and NaN fail with invalid_input and are not billed. On success the body echoes rounded keystrokes and minutes, returns hours as minutes divided by sixty, keystrokes_per_minute as the raw quotient, and keystrokes_per_hour as the primary hourly rate, plus a formula string restating keystrokes divided by minutes times sixty. Successful API calls use the published $0.002 base price.
Where a keystrokes-per-hour calculator earns its keep
Workforce dashboards store raw counts from any desktop agent and call this tool once to fill a consistent keystrokes_per_hour column for charts. That keeps latency at a handful of arithmetic operations and keeps the cost model honest at $0.002 per successful API request, while failed validation never consumes prepaid balance.
Integration use cases
Workforce log normalization
Desktop agents store raw key counts and elapsed minutes; call this tool once to fill a consistent keystrokes_per_hour column for dashboards and payroll reviews.