Keyboard Latency Test — Measure Input Lag & Jitter Online

This keyboard latency test measures how long your browser takes to hand each key event to JavaScript, in milliseconds. Press any key and you get a running minimum, average, maximum and jitter figure plus a per-key log. It is a fast way to spot an unstable input path — and further down there is an honest account of the part of the chain this number cannot see.

How keyboard latency is measured

A keypress is not one event, it is a relay race. The switch travels to its actuation point, the controller sees the contact close on its next matrix scan, a debounce routine waits out the contact bounce, the firmware builds a USB HID report, that report waits for the host's next poll, and the driver stack timestamps it and hands it to the focused application. Only then can anything reach the screen.

Instrumented reviews measure one slice of that chain with hardware. RTINGS starts its clock when a solenoid touches the keycap and stops it when the matching USB packet reaches the host, which captures switch travel, debounce, scan and transmission but stops before the operating system. A high-speed camera pointed at the display measures almost the opposite: everything, including the panel. Two honest methods, two very different numbers for the same keyboard.

Latency and jitter are not the same number

Latency is how long one keystroke takes. Jitter is how much that time changes between consecutive keystrokes; this page reports it as the average absolute difference from one sample to the next. A board that is consistently 8 ms feels more predictable than one swinging between 2 ms and 20 ms, even with a better best case. When comparing two keyboards, read the jitter before the average.

What this browser test can and cannot measure

A browser cannot measure true end-to-end hardware latency, and any page claiming otherwise is guessing. What this test times is the gap between the timestamp the browser attaches to a key event and the moment your JavaScript handler actually runs — the tail of the chain, inside the machine, after the operating system has already done its work.

Counted in the number you see:

Browser event-queue and main-thread delay, including work from the page itself, other tabs and extensions
Scheduling jitter from the OS when the CPU is loaded or a power-saving profile is active

Not counted, and not measurable from a web page:

Switch travel to the actuation point, and how fast and hard you press
The keyboard's debounce window, often around 1–8 ms and frequently the largest single term
Matrix scan interval and firmware processing inside the keyboard
USB or wireless transmission, plus the wait for the next poll — up to 8 ms at 125 Hz, about 1 ms at 1000 Hz
Driver and HID stack time before the browser receives its timestamp
Everything after delivery: game engine tick, frame render and the display pipeline, which together usually dwarf all of the above

One more limit matters. Browsers deliberately coarsen high-resolution timers to blunt side-channel attacks, so sub-millisecond readings are rounded and should be read as “below the noise floor” rather than as precise values; a reading of 0.00 ms is a genuine result meaning the delay was shorter than your browser's timer can resolve, not an error. And when a key event's timestamp cannot be compared with the page's own clock at all — in some browsers and embedded contexts the two run on different time bases — that keystroke is marked not measurable in the log and left out of the minimum, average, maximum and jitter. No substitute number is invented in its place. Treat this tool as a stopwatch, not a logic analyser: run it on one machine and browser with one keyboard, then the other. The relative difference is meaningful even though the absolute value is incomplete.

What is a good keyboard latency

In this keyboard latency test an average under 5 ms is excellent, 5–10 ms is good, 10–20 ms is fair, and anything past 20 ms means something on your system is delaying event delivery — a background process, a loaded tab, a power plan or a driver problem. Those bands describe the browser-side number, not your hardware.

For the hardware itself, instrumented measurements put current gaming keyboards in the low single-digit milliseconds, mainstream office and laptop boards somewhere in the teens, and some older wireless designs above 20 ms. Independent single-key testing has repeatedly found ordinary keyboards adding 15–60 ms before the OS sees the press, which is why measured figures beat marketing claims.

Keep the scale in mind: human reaction time in a simple visual task averages roughly 200–270 ms. Trimming 5 ms off your keyboard is real, but small next to your monitor, your frame time and your network. Fix the biggest term first.

Wireless vs wired vs Bluetooth

Wired is still the floor, but the gap has narrowed. A wired keyboard polled at 1000 Hz waits at most 1 ms for its turn on the bus. A modern 2.4 GHz dongle runs its own radio protocol at a comparable report rate and lands roughly 1–5 ms behind wired, close enough that most people cannot pick them apart blind.

Bluetooth is the outlier. It is built for battery life, not speed: connection intervals are rarely as aggressive as a dedicated receiver's, and power-saving sleep states mean the first keypress after a pause can arrive late even when steady typing feels fine. If your keyboard supports both, use the dongle for games and Bluetooth for writing.

A browser keyboard latency test cannot tell you which of the three you are on, because transmission happens before the browser's timestamp. What it can show is instability: if jitter climbs when you move the keyboard away from the receiver or switch to Bluetooth, the radio link is the suspect. To look at report rate itself, use the keyboard polling rate test, which is a separate measurement with its own browser-side limits.

Why browser numbers differ from published reviews

Because the two measurements start and stop in different places. A review's figure runs from switch contact to USB packet and ignores everything your PC does next; this page's figure starts after the OS timestamp and ignores everything before it. Neither is wrong, and they were never going to match.

The second reason is that your result is not a clean-room result. Browser measurements move with CPU load, battery-saver profiles, USB hubs and remote sessions. Forum threads about a web-based keyboard latency test are full of people posting 40 ms and asking whether their keyboard is broken; usually the tool was reading system conditions, not the switch.

So treat a bad number as a starting point, not a verdict. Close other tabs, bypass any hub and retest. If keys are not registering at all, latency is the wrong diagnostic — run the keyboard tester first to confirm every key reports an event. If one press produces two characters, that is contact bounce rather than delay, and the keyboard double click test will confirm it in seconds.

Frequently asked questions

What input lag is acceptable for gaming?

Under 10 ms of keyboard latency is fine for almost everyone, and under 5 ms is competitive-grade. Instrumented tests put good gaming boards at 1–5 ms and ordinary office keyboards in the teens. Below roughly 5 ms the keyboard stops being the bottleneck: your monitor's pipeline and your own reaction time, which averages over 200 ms, dominate what you actually feel.

Is there latency with wireless keyboards when you're gaming?

Yes, but with a good 2.4 GHz dongle it is about 1–5 ms, which almost nobody can feel. Dedicated gaming receivers run their own radio protocol at report rates comparable to wired USB. The real wireless risk is interference and dropouts rather than raw delay — a hub, a nearby USB 3 port or a metal desk around the receiver hurts consistency far more than the radio does.

Is Bluetooth slower than a 2.4 GHz dongle?

Yes, usually by several milliseconds. Bluetooth is tuned for battery life: its connection intervals are longer than a dedicated receiver's, and power-saving sleep means the first keypress after idle can arrive noticeably late. A 2.4 GHz dongle holds a dedicated link open at a much higher report rate. For typing the difference is invisible; for games, use the dongle if your keyboard ships with one.

Does polling rate and response time help in gaming?

They help, but they are not the same thing. Polling rate is how often the host asks the keyboard for its state — 1000 Hz means every 1 ms. Response time is the whole path from switch contact to the event reaching software, which also includes debounce, matrix scan and transmission. Polling only sets the worst-case wait: a 1000 Hz board with an 8 ms debounce is still slower than a 500 Hz board with 2 ms.

I ran a keyboard latency test and got 41 ms — is that okay?

Almost certainly it is not your keyboard. A web-based reading that high reflects system conditions: background CPU load, a power-saving profile, a USB hub, a remote session or a busy browser tab. Retest with other tabs closed and the keyboard in a rear port. Browser tools only see the chain after the OS timestamp, so they pick up every delay your PC adds on top of the hardware.

Can you measure keyboard input latency without a high-speed camera?

Only partially. Software-only methods, including this page, time the chain after the operating system has already timestamped the event, so they miss switch travel, debounce and transmission. Getting true end-to-end numbers needs hardware: a solenoid or logic analyser on the switch side, or a high-speed camera on the display side. Software measurements are still useful for comparing two keyboards on the same machine.

My keyboard suddenly lags when I play games — what causes input lag?

Start with software, not the switch. Input lag that shows up only in games usually traces to background load — voice chat, overlays, capture software, open browser tabs — or a power plan that parks CPU cores. Update or roll back the keyboard driver, disable in-game overlays one at a time, and try the same keyboard on another machine. Hardware that was fine last month rarely degrades this abruptly.