Keyboard Performance Test
Five browser-side checks in one guided pass — input event latency, input-to-frame time, key detection coverage, duplicate events and simultaneous keys — combined into a single transparent report for this browser session.
Run the five-stage diagnostic
What this measures
Everything on this page is measured inside your browser: the delay between the browser stamping a key event and this page's JavaScript seeing it, the extra wait until the next animation frame, whether specific physical keys arrive at all, whether a single press produces two events, and how many keys the browser reports as held at once. That is the browser input pipeline and main-thread scheduling — not switch actuation, firmware or transmission. Read how we measure.
Stage 1 runs the same measurement as the keyboard latency test. Use that page if latency is all you want, with a larger sample target and a fuller statistical breakdown; use this one to sweep all five checks in a single pass and get one combined report.
Stage 1 of 5 · 0 of 5 stages resolved
Stage 1 · Input event latency
Press any 30 keys at a comfortable pace. Each press is timed as
performance.now() read at the top of the handler, minus the browser's own
event timestamp. That gap is browser event creation, queueing and main-thread scheduling
— not keyboard hardware.
—
Press Start stage, then type normally. 0 of 30 samples collected.
Distribution of input event latency. The histogram appears once samples are collected.
No samples excluded.
Excluded events for this stage
| Key | Code | Reason |
|---|---|---|
| Nothing excluded yet. | ||
Stage 2 · Input-to-frame time
The same presses, measured to the next animation frame instead of to the handler. This adds the wait for the browser's next rendering opportunity, so it is strongly influenced by your display refresh rate. It is a browser-side lower bound on when pixels could change — not a measurement of your monitor.
—
Press Start stage, then press 20 keys. 0 of 20 samples collected.
Distribution of input-to-frame time. The histogram appears once samples are collected.
No samples excluded.
Excluded events for this stage
| Key | Code | Reason |
|---|---|---|
| Nothing excluded yet. | ||
Stage 3 · Key detection coverage
Press each of the twelve keys below once. Matching is by physical
key position (event.code), so it behaves the same on QWERTY, AZERTY, QWERTZ,
Dvorak and Colemak. Labels are shown for reference only.
Press Start stage, then press each key once. 0 of 12 registered.
- AKeyAwaiting
- SKeySwaiting
- DKeyDwaiting
- FKeyFwaiting
- JKeyJwaiting
- KKeyKwaiting
- LKeyLwaiting
- 1Digit1waiting
- 0Digit0waiting
- SpaceSpacewaiting
- ←ArrowLeftwaiting
- ↑ArrowUpwaiting
No samples excluded.
Stage 4 · Chatter check
Type roughly forty deliberate, separate presses. A duplicate
keydown for the same physical key within 15 ms, with
repeat false, is flagged as a possible chatter event. This is the same
detection rule used by the dedicated keyboard chatter
test.
0
Press Start stage, then type about 40 separate presses. Duplicate events under 15 ms are counted here.
| # | Key | Code | Gap (ms) |
|---|---|---|---|
| No duplicate events detected yet. | |||
No samples excluded.
Stage 5 · Simultaneous key check
Hold several keys down together and keep adding more without releasing. The peak number your browser reported as held at the same time is recorded. This is a browser-observed count — the browser, the OS and the keyboard can each limit it, and this stage carries no weight in the score.
0
Press Start stage, then hold as many keys as you can at once. Currently held: none.
No combination recorded yet.
No samples excluded.
Browser Test Profile
What this number is The Browser Test Profile describes this browser session, on this machine, under these conditions. It is not a hardware rating and it is not comparable between different computers, browsers, operating systems or display refresh rates. Use it to compare runs you take yourself.
No stages have run yet.
Score breakdown
| Component | Measured | Sub-score | Weight | Contribution | Status |
|---|---|---|---|---|---|
| No stages have run yet. | |||||
Weighted contribution of each scored component. The chart appears once a stage has produced data.
The exact weighting and thresholds
This is the whole formula. Each raw measurement is converted to a sub-score from 0 to 100 by linear interpolation between the anchor points below, clamped at both ends. Each sub-score is multiplied by its weight, the weighted values are summed, and the sum is divided by the total weight of the components that actually ran.
| Component | Weight | Raw measurement | Sub-score anchors |
|---|---|---|---|
| Event latency median | 30 | Median browser input event latency, stage 1 | ≤4 ms = 100 · 8 ms = 85 · 16 ms = 60 · 32 ms = 30 · ≥64 ms = 0 |
| Consistency (CV) | 25 | Coefficient of variation of the stage 1 samples | ≤0.05 = 100 · 0.15 = 85 · 0.30 = 60 · 0.50 = 30 · ≥1.00 = 0 |
| Key detection coverage | 20 | Keys registered out of the 12 in stage 3 | Sub-score = 100 × registered ÷ 12 |
| No-chatter | 15 | Duplicate same-key events under 15 ms in stage 4 | 0 = 100 · 1 = 60 · 2 = 30 · 3 or more = 0 |
| Input-to-frame | 10 | Median input-to-frame time, stage 2 | ≤8 ms = 100 · 16 ms = 85 · 24 ms = 60 · 40 ms = 30 · ≥70 ms = 0 |
| Simultaneous keys (stage 5) | 0 | Peak simultaneous keys reported by the browser | Reported only. The §1.9 weighting has no rollover term, so this stage never changes the score. |
A component is only scored when its stage produced enough data to support it: 3 or more valid samples for the event latency median, 2 or more for the coefficient of variation, 3 or more for input-to-frame, at least one recorded press for coverage, and 5 or more recorded presses for the chatter check. Below those minimums the component is marked Not enough data, its weight is removed, and the score is re-normalised exactly as it is for a skipped stage.
The anchor values above are thresholds chosen for this page and published so you can check them. They are not an industry standard and no measurement here is compared against any external benchmark.
Advanced data
| Stage | Statistic | Value |
|---|---|---|
| No stages have run yet. | ||
Saved reports stay in this browser only and can be loaded on the session comparison page. Nothing is uploaded.
Measurement environment
Timer resolution: — High-resolution timing: — Browser: — Platform: —
These conditions affect your result. A browser that rounds its clock to 1 ms cannot resolve sub-millisecond differences, so jitter will look artificially quantised. How we measure.
This browser reports time in whole milliseconds. Results on this page are quantised to 1 ms steps, so fine-grained jitter and consistency cannot be resolved and the consistency sub-score will be coarser than on a browser with a finer clock.
What this test cannot tell you
This runs in a web browser, so it can only see keyboard events after your operating system has already delivered them. It cannot isolate switch actuation, keyboard firmware, matrix scanning, USB or Bluetooth transmission, OS scheduling, or your display's response time. Measuring those requires dedicated hardware instrumentation.
The Browser Test Profile is therefore a description of a browser session, not a rating of a keyboard. It cannot tell you that one keyboard is faster than another, it cannot diagnose a hardware fault on its own, and a score from your machine is meaningless next to a score from someone else's. A low chatter or coverage result is a pattern worth investigating — on a different port, a different cable and a different computer — not a verdict.
What each of the five stages measures
The stages are deliberately different measurements, not five views of one number.
Stage 1 times the gap between the browser creating a key event and this page's handler
running — queueing plus main-thread scheduling. Stage 2 extends that to the next
animation frame, folding in the wait for the browser's next rendering opportunity, so it is
dominated by your refresh rate. Stage 3 checks that twelve specific physical keys reach
the browser at all. Stage 4 looks for one key producing two keydown events
within 15 ms. Stage 5 counts how many keys the browser reports as held at once.
Only stages 1 to 4 feed the score, because those are the four things the published weighting covers. Stage 5 is reported for context; adding it to the score would mean inventing a weight the specification does not define.
How the score is built, and why skipping matters
Each component produces a sub-score from 0 to 100 using the anchor table printed above. The sub-score is multiplied by its weight, the weighted values are added up, and the total is divided by the sum of the weights that actually contributed. Nothing is smoothed, capped or curved beyond what that table says.
Skipping removes weight rather than substituting a value. Skip the chatter stage and its 15 points leave both the numerator and the denominator, so the remaining 85 are re-normalised back to a 0–100 range. Scoring a skipped stage as zero would punish you for not running it; scoring it as full marks would flatter you for the same reason. The report instead names every stage that was skipped or never run, and states how many of the 100 weight points the number came from. The same rule applies when a stage runs but cannot produce a usable statistic: two samples are not enough for a coefficient of variation, so that component is excluded and labelled rather than guessed.
Why two computers cannot be compared
Browser input latency is mostly a story about scheduling. A busy main thread, a background
tab decoding video, a power-saving CPU governor, a different OS input pipeline, or a browser
that coarsens its clock for security will all move the numbers independently of the keyboard.
Chrome clamps performance.now() to roughly 100 microseconds; Firefox clamps
to 1 millisecond unless the page is cross-origin isolated. With a 1 ms clock every
value is rounded to a whole millisecond before you see it, which mechanically inflates the
measured coefficient of variation on fast systems.
That is why this page publishes no leaderboard, benchmark table or comparison against named keyboards. The honest use of the score is longitudinal: run it, change one thing — a different port, a different cable, wired instead of wireless, fewer tabs — and run it again on the same machine. The session comparison tool exists for exactly that, and why keyboard latency results vary between systems covers where the variation comes from.
Reading a low sub-score
A high median with a low coefficient of variation usually points at a steady, structural delay: a busy machine, a loaded browser, or an extension that installs its own key handlers ahead of the page. A low median with a high coefficient of variation points the other way — usually fast, but something intermittently blocks the main thread. Garbage-collection pauses, background downloads and screen-recording software all produce that signature.
A coverage miss in stage 3 has several possible explanations and the browser cannot distinguish between them: the key may not be registering, the operating system or a remapping utility may be intercepting it, or the browser may reserve it. A duplicate event in stage 4 is a possible chatter pattern that can equally come from a macro, an accessibility feature, or genuinely pressing one key twice very fast. Confirming either needs the dedicated chatter test or keyboard tester, ideally on a second computer.
Getting a result worth keeping
Keep the window focused and use your normal typing rhythm. Deliberately slow, evenly spaced presses produce a flattering consistency figure that does not describe how you actually type. Thirty valid samples is roughly where the median and percentile figures stop moving between runs; under ten, the quality indicator says Insufficient, and it means it. The guide on how to test keyboard latency walks through a good measurement run step by step.
Exclusions and test quality
Nothing is silently discarded. Every key event that fails a validation rule is counted, labelled with its reason and listed in the per-stage disclosure: key-repeat, window lost focus, tab not visible, synthetic event, unusable timestamp, clock anomaly, above the 250 ms cutoff, or a bare modifier key in the latency stage. A high exclusion ratio is itself information — usually that focus was moving around, or a key was held down.
The quality label combines four things: valid samples collected, the fraction of events excluded, how many times focus or tab visibility was lost, and whether the clock is fine-grained enough to resolve sub-millisecond differences. A profile labelled Excellent and one labelled Limited are not equally trustworthy, and the report says which you have.
Related keyboard tests
Frequently asked questions
Does this test measure my keyboard's hardware latency?
No. Every number on this page is measured inside a web browser, after the operating system has already delivered the key event. It describes the browser input pipeline and main-thread scheduling on this machine, in this browser, right now. Switch actuation, matrix scanning, firmware, USB or Bluetooth transmission and display response are all invisible to it and would need dedicated hardware instrumentation to measure.
What is the Browser Test Profile score?
It is a 0-100 summary of the five stages, weighted as event latency median 30, consistency 25, key detection coverage 20, no-chatter 15 and input-to-frame 10. The full weighting table and every threshold used to convert a raw measurement into a sub-score are printed on this page. It is a description of this browser session under these conditions, not a rating of your keyboard.
Can I compare my score with someone else's?
No, and you should not try. The score depends on your browser's timer resolution, your CPU load at that moment, your operating system's input handling, your display refresh rate and how many other tabs are running. Two different computers can produce very different scores with identical keyboards. The score is only useful for comparing runs you take yourself, ideally back to back on the same machine.
What happens to the score if I skip a stage?
The weight of every component that stage would have supplied is removed from the total, and the score is re-normalised over the weight that actually ran. A skipped stage is never scored as zero and never scored as full marks. The report names every stage that was skipped or not run, and states how many of the 100 weight points the score was computed from.
Why were some of my key presses excluded?
Samples are excluded when they cannot be trusted: key-repeat events from holding a key, presses while the window did not have focus or the tab was hidden, synthetic events, unusable timestamps, negative values from clock anomalies, values above the 250 ms cutoff, and bare modifier keys in the latency stage. Every exclusion is counted and listed rather than silently dropped, because a hidden exclusion would quietly flatter the result.
How many key presses does the full test need?
About 100 in total: 30 for input event latency, 20 for input-to-frame time, 12 for key detection coverage, roughly 40 for the chatter check, and one held combination for the simultaneous key check. Fewer samples still produce a result, but the test quality indicator will say the result is Limited or Insufficient rather than pretending a handful of presses is enough.