What Is Keyboard Latency? A Clear Explanation

Keyboard latency is the time between a key physically closing its circuit and the result of that press becoming visible on screen. It is not one delay — it is a chain of them.

Measure it in your browser

Published 15 August 2026 · Last updated 15 August 2026

The short definition

Keyboard latency is the delay between a physical key press and the visible result of that press. Every stage between your fingertip and the pixel adds a little, and the stages you can most easily buy your way out of are usually not the ones adding the most.

Because it is a chain, the phrase is ambiguous unless you say where the stopwatch starts and where it stops. That single ambiguity is responsible for most of the confusion — and most of the arguing — you will find on the subject.

The chain, stage by stage

A key press has to travel through eight distinguishable stages before you can see anything happen. They run strictly in series, so the delays add.

The input chain from switch to pixel. Each stage runs after the one above it.
#StageWhat happensControlled by
1ActuationThe switch travels far enough for its contacts to close, or for a Hall-effect or optical sensor to cross its threshold.Switch design and how fast you move
2DebounceFirmware waits briefly to confirm the contact is genuinely settled rather than bouncing.Keyboard firmware
3Matrix scanThe controller sweeps rows and columns and notices which key changed state.Keyboard firmware
4Report and transmissionThe key state is packed into an HID report and sent over USB, Bluetooth or a proprietary wireless link at that link's own cadence.Keyboard and the link
5Host and OS input stackThe host controller signals the CPU, a driver decodes the report, the OS routes it to the focused window.Operating system
6Application processingThe game, editor or browser reads the input and updates its state — often only once per frame.Software
7Render and presentA new frame is drawn, queued, composited and handed to the display output.GPU, compositor, OS
8DisplayThe panel scans the frame out and the pixels physically change.Monitor

How big is each stage, realistically

Specific millisecond figures for named products are exactly the kind of thing that gets repeated forever after being measured once, badly. What follows is the shape of each stage and what makes it larger or smaller, not a leaderboard.

Actuation and debounce

Actuation is partly you. A shorter actuation point means your finger has less distance to cover before the switch registers, which shortens the mechanical portion of the press — but it changes nothing downstream. Debounce is the firmware pausing to make sure a contact that just closed is not still bouncing; keyboards commonly wait a small number of milliseconds. Very aggressive debounce settings shave that wait at the cost of a higher chance of one press being reported twice, which is the failure mode our keyboard chatter test looks for.

Matrix scanning and firmware

The controller does not watch every key continuously; it scans the switch matrix in a loop. A press that happens just after its row was scanned waits for the next sweep. Modern controllers scan quickly enough that this is usually a small term rather than a dominant one, but it is genuinely there, and it is one of the things firmware authors tune.

Transmission

This stage is the one you can actually do arithmetic on. A USB device polled at 1000 Hz gets a transmission opportunity every 1 ms. A key press arrives at a random moment inside that window, so on average it waits half the window — 0.5 ms — and at worst a full 1 ms. At 125 Hz the window is 8 ms, so the average wait is 4 ms and the worst case is 8 ms.

Wireless varies much more. Dedicated 2.4 GHz receivers are generally designed to keep this term low and steady, while Bluetooth negotiates a connection interval with the host that is typically longer and less under the keyboard's control — one reason Bluetooth keyboards more often feel slightly behind. Work the numbers yourself with the polling rate calculator.

The operating system

Normally small, but not fixed. It depends on driver behaviour, scheduling, power states and what else is competing for the CPU. This is the first stage where "how busy is this machine right now" starts to matter, and a large part of why the same keyboard does not produce identical numbers twice in a row.

The application

Highly variable and frequently underestimated. A game that reads input once per frame quantises your press to its own frame boundary regardless of how fast the keyboard was. A web page whose main thread is busy will run its key handler late. This is the stage the tests on this site can actually observe.

The display

A display shows a new frame on a fixed cadence. At 60 Hz that is one frame every 16.7 ms; at 144 Hz, 6.9 ms; at 240 Hz, 4.2 ms. On top of the refresh cadence sit the pixel transition time and whatever processing the panel itself does before it starts drawing.

Why the display is usually the larger term

Apply the same "random arrival waits half the window" logic that made polling rate tractable. A press that lands at a random point in a refresh cycle waits on average half a cycle before the frame carrying its result even begins to be drawn.

Now compare that to the transmission stage. Moving from 125 Hz to 1000 Hz polling removes about 3.5 ms of average wait. Half a 60 Hz display cycle costs more than twice that on its own — before adding pixel response, panel processing, or the fact that the application render loop is usually frame-quantised too. You often end up with two or three frame-locked stages in series near the end of the chain.

The ordering argument

None of this means the keyboard is irrelevant. It means that if you are hunting for milliseconds, the frame-cadence end of the chain usually has more of them available to remove than the transport end does. A 1000 Hz keyboard attached to a 60 Hz display running an application at 45 fps is optimising the smallest term in the sum.

Three professions, three definitions

The reason two honest sources can quote wildly different figures is that they are clocking different intervals. Nobody is lying; they are answering different questions.

The same phrase, four different intervals.
Who is speakingClock startsClock stopsUsually called
Switch or keyboard makerContact closure or sensor thresholdThe HID report leaves the device"Response time", "input latency"
OS or driver engineerThe host controller signals the CPUThe event reaches the focused application"Input stack latency"
Gamer or hardware reviewerThe finger starts moving, or a trigger firesThe pixel visibly changes"Click-to-photon", "end-to-end latency"
Web developerThe browser creates the key eventThe handler runs and the change is painted"Input event latency"

The switch manufacturer's number can be a fraction of the gamer's and both can be correct, because the gamer's interval contains the manufacturer's plus five more stages. The useful question about any latency figure is not "is that good?" but "what exactly was clocked?" — the whole subject of what counts as a good keyboard latency.

What a browser test can and cannot see

A web page receives a keyboard event only after the operating system has already delivered the input to the browser. The browser stamps the event when it creates it, and JavaScript can compare that stamp against the moment its own handler starts running. That difference is a real, reproducible measurement of the browser input pipeline and main-thread scheduling — stages 5 through 7 in the table above, and only partially.

Stages 1 through 4 happen before the browser has any knowledge of the event at all. No amount of JavaScript can recover them, and any site that claims to report your switch, firmware or USB timing from a web page is describing something it cannot see.

What a browser measurement cannot tell you

Browser-side timing cannot isolate switch actuation, debounce, matrix scanning, USB or Bluetooth transmission, or your display's response time. It also cannot see how long the operating system held the input before handing it over. Measuring those stages requires dedicated hardware instrumentation, described in how keyboard latency is measured.

Read the full methodology and limitations

Measure the part you can actually see

The browser-side segment is worth measuring on its own terms. It is where a stuttering main thread, an overloaded machine or an aggressive background process shows up, and it is the part of the chain that changes most from moment to moment on the same hardware. Run the browser-based keyboard latency test to see your own median, percentiles, jitter and consistency, then read how to test keyboard latency properly so the number you get is worth comparing to anything.

Related tests and guides

Frequently asked questions

Is keyboard latency the same as input lag?

People usually say input lag to mean the whole chain from finger to visible pixel, and keyboard latency to mean only the part contributed by the keyboard itself. Because the terms are used loosely, always ask where the measurement starts and where it stops before comparing two numbers.

Which stage of the chain is usually the largest?

On a typical desktop the display and the application render loop usually contribute more than the keyboard does. A 60 Hz display presents a new frame every 16.7 ms, and a press landing at a random moment waits about half that on average before the frame carrying its result even begins.

Can a website measure my keyboard's hardware latency?

No. A web page only sees keyboard events after the operating system has already delivered them to the browser. Everything upstream of that point, including the switch, the firmware and the USB or Bluetooth link, is invisible to JavaScript. Isolating those stages needs dedicated hardware instrumentation.

Does a higher polling rate reduce keyboard latency?

It reduces one specific term: how long a finished key report waits for its next transmission opportunity. Going from 125 Hz to 1000 Hz shortens that wait from an average of 4 ms to an average of 0.5 ms. That is a real improvement, but it is small next to a single frame of display time at a low refresh rate.