Keyboard Chatter Test
Type normally and this page watches for a second keydown arriving suspiciously soon after a key was released — the browser-observed signature of switch chatter, with held-key auto-repeat deliberately excluded.
Chatter test
Click or tab into this box, then type normally for 20–30 seconds — ordinary sentences work better than mashing. Press Tab or click outside to stop capturing keys.
0 presses recorded · 0 distinct keys · 0 auto-repeat events ignored
No suspected chatter detected yet Keep typing — a few hundred presses gives a much clearer picture than a few dozen.
A second keydown arriving this soon after the same key’s release is flagged as a suspected duplicate. Moving this re-evaluates every event already recorded.
Loading keyboard map…
Pressed ! Suspected chatter Keys with suspected duplicates also show a count on the cap and are listed in the per-key table below.
Results
Same-key re-press gaps
Every time you press a key that you had just released, the gap between the release and the new press is recorded here. Normal typing produces gaps of roughly 80–400 ms. A separate cluster squeezed against zero is the chatter signature.
The distribution appears once you have pressed the same key more than once.
Gaps longer than 500 ms are excluded from the chart so the fast cluster stays readable.
Per-key breakdown
| Key | Code | Presses | Suspected chatter | Rate | Shortest gap (ms) |
|---|---|---|---|---|---|
| No keys pressed yet. | |||||
Suspected chatter events
| # | At (s) | Key | Code | Gap (ms) | Previous hold (ms) |
|---|---|---|---|---|---|
| Nothing flagged yet. | |||||
Advanced data
No samples excluded.
Test quality: collecting.
| Statistic | Value |
|---|---|
| No re-press gaps recorded yet. | |
Percentiles use linear interpolation on the sorted gaps. P95 needs at least 10 gaps and P99 at least 20, so they show an em dash until then. Full statistical definitions.
Exports are generated in your browser from the data on this 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 the keyboard firmware, the USB or Bluetooth link and your operating system have already handled them. It cannot inspect a switch, measure contact bounce at the contacts, or confirm that any component is faulty.
A flagged event means the browser received two presses of the same key unusually close together. That is a pattern worth investigating, not a diagnosis. Remapping and macro software, accessibility filters, virtual machines, remote-desktop sessions and genuinely fast double taps can all produce the same pattern, and a heavily loaded machine can also distort the timing of the events themselves.
What keyboard chatter actually is
Chatter, also called double-typing, is when one deliberate press of a key produces two or more separate key events. You type the and get thhe. On a mechanical switch the usual physical cause is contact bounce: the metal contacts do not close cleanly but rattle for a fraction of a millisecond as they meet, and if the keyboard's debounce logic no longer filters that rattle, the firmware reports it as two presses.
Debounce timing is a firmware setting, typically in the region of 5 to 10 milliseconds, though it varies by design and can often be raised on boards running custom firmware. Chatter tends to appear on one or two specific keys rather than the whole board, and usually gets worse as a switch ages or picks up contamination.
How this test decides an event is suspicious
The page listens for keydown and keyup on the window. For each key
code it remembers when that key was last released. When the same code produces a fresh
keydown, it records the gap between the release and the new press. If that gap is
at or below your threshold — 15 ms by default, adjustable from 5 to 50 ms
— the event is listed as a suspected duplicate.
One rule matters more than all the others: every event where the browser sets
event.repeat to true is discarded before detection runs. Those are
operating-system auto-repeat events generated while you hold a key down, and they arrive far
faster than any chatter threshold. A test that counts them reports hundreds of imaginary
chatter events the moment you lean on a key. This page counts them separately and shows the
total so you can see they were handled, and the same is true of untrusted synthetic events,
events that arrive while the window has lost focus, and events with an unusable timestamp.
Why a flagged event might not be chatter at all
The honest reading of a flagged event is “two presses of this key reached the browser unusually close together”. Several ordinary things produce exactly that:
- Fast intentional double taps. Gaming and shortcut habits produce genuine double presses, though almost never inside 15 ms.
- Rollover during fast typing. When keys overlap heavily, releases and presses can land very close together in the event stream.
- Remapping, macro and layer software. Anything that synthesises key events — AutoHotkey, driver macro engines, keyboard layer tools, text expanders — can emit bursts the browser reports as ordinary presses.
- Virtual machines and remote desktops. Input is re-injected on the far side, so event timing is reconstructed rather than original.
Real chatter has a shape: it clusters on one or two keys, the gaps are consistently tiny, and the press that precedes the duplicate is often held for only a few milliseconds. A single isolated flag across hundreds of presses is much more likely to be one of the causes above.
Filter Keys, Bounce Keys and Slow Keys
Operating-system accessibility features sit between the keyboard and the application, and they can both hide and create odd repeat behaviour. On Windows, Filter Keys covers Bounce Keys (ignore a repeated press of the same key that arrives too quickly) and Repeat Keys / Slow Keys (change how long a key must be held before it registers). macOS has an equivalent Slow Keys setting alongside its key-repeat controls.
If Bounce Keys is active, real chatter may be filtered out before the browser ever sees it, and this test will report nothing while you still see double letters in some other application that is fed differently. If Slow Keys is active, presses are delayed and reshaped, so the gaps on this page no longer describe what the keyboard sent. Check these settings before you trust either a clean result or a noisy one.
Reading the gap histogram
The histogram plots every same-key re-press gap, not just the flagged ones. Comfortable typing usually puts the same key down again somewhere around 100 to 400 ms later, so a healthy board produces one broad hump in that region and nothing else. Chatter shows up as a second, separate cluster jammed against the left edge, in the 0–15 ms range, with a clear empty gap between the two groups. That separation is the useful signal; a smear that runs continuously from 5 ms up to 200 ms is much more likely to be typing behaviour than a switch.
Timer resolution sets a floor here. If your browser reports a 1 ms clock, every gap is quantised to whole milliseconds and the fast cluster collapses into a single bar. The measurement environment panel above shows the resolution measured in your browser.
If the pattern looks real
Reproduce it first. Try a different USB port and cable, quit remapping and macro tools, switch off Filter Keys or Slow Keys, and if you can, try the keyboard on a second computer — that separates the board from the software on any one machine.
If the same key still produces tight clusters everywhere, the common remedies are raising the firmware debounce time where the keyboard supports it (QMK, VIA and several vendor configurators expose this), cleaning or reseating the switch, or replacing it on a hot-swap board. The CSV export from this page is a concrete thing to attach to a warranty ticket.
Read the full guide to keyboard chatter, or measure overall input timing with the keyboard latency test.
Related keyboard tests
Frequently asked questions
What counts as keyboard chatter?
Chatter — also called double-typing — is when one physical press produces two or more separate key events. This test flags a suspected chatter event when the same key code produces a second keydown within your chosen threshold (15 ms by default) of that key's keyup, and the browser reported that event as a fresh press rather than an auto-repeat.
Why does this test ignore auto-repeat events?
When you hold a key down, your operating system generates a stream of repeat events, and the browser marks each one with event.repeat set to true. Counting those as duplicates would report hundreds of false chatter events from a single held key. This test discards every event with event.repeat set to true before chatter detection runs, and shows you how many repeat events it discarded.
Can a browser test prove that a switch is faulty?
No. A browser only sees key events after the keyboard firmware, the USB or Bluetooth link and the operating system have already processed them. A cluster of very short gaps on one key is a strong hint worth investigating, but remapping software, macro tools, accessibility settings and genuinely fast double taps can all produce the same pattern. Reproducing it on another computer, and in another application, is the useful next step.
What chatter threshold should I use?
15 ms is a sensible default because most keyboard firmware debounces for roughly 5 to 10 ms, and deliberately pressing the same key twice within 15 ms is close to impossible. Lower the threshold to 5 ms if you want only the most clear-cut duplicates. Raise it toward 50 ms if you suspect a slower bounce, and accept that fast double taps and rollover during quick typing will start appearing in the results.
Can Windows Filter Keys or macOS Slow Keys change the result?
Yes, in both directions. Windows Filter Keys (which includes Bounce Keys and Repeat Keys) and the macOS Slow Keys setting sit between the hardware and the application and can suppress rapid repeated presses, which masks real chatter. They can also delay or reshape events so the timing you see here no longer reflects what the keyboard sent. If you are diagnosing chatter, check that these settings are off first.
Why does the shortest gap never go below 1 ms in my browser?
Browsers deliberately coarsen their high-resolution clock to limit timing side-channel attacks. Firefox rounds to 1 ms unless the page is cross-origin isolated, and Chromium rounds to about 100 microseconds. This page probes the clock and reports the resolution it measured in the measurement environment panel — if that value is 1 ms, every gap you see is quantised to whole milliseconds and differences finer than that cannot be resolved.