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.

Start stage 1

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.

Median latency ms P50 of valid samples
Jitter ms Mean successive difference
Consistency Label plus the CV that produced it
P95 ms Needs 10 or more samples
Valid samples 0 Target 30

Distribution of input event latency. The histogram appears once samples are collected.

No samples excluded.

Excluded events for this stage
KeyCodeReason
Nothing excluded yet.
Jump to report

Browser Test Profile

Browser Test Profile / 100 Run at least one stage to produce a profile.
Weight used 0of 100 Skipped components are removed and the score re-normalised
Test quality From valid samples, exclusions, focus losses and timer resolution

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

Every component, its measured value, its sub-score and its contribution. Contributions are already re-normalised, so they add up to the score exactly.
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.

Browser Test Profile weighting (BUILD-SPEC §1.9) and the conversion thresholds used on this page
ComponentWeightRaw measurementSub-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
StageStatisticValue
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.

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.

Read the full methodology and limitations

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.