Keyboard Test

Keyboard Tester - Test Your Keyboard Online Free

Test every key on your keyboard instantly with this free online tool. Press any key and see it register in real time — no download, no account, and no software installation required. Diagnose unresponsive keys, verify modifier combinations, and confirm function keys work correctly on any keyboard type.

Why Test Your Keyboard Online

A keyboard that looks fine can still have hidden problems. A key might register inconsistently under fast typing, a modifier key might not pair correctly with other keys, or wireless latency might cause inputs to arrive out of order. Testing your keyboard online gives you a clear, objective view of exactly what your hardware is sending to the operating system.

This tool uses the browser's native KeyboardEvent API to capture every key event your operating system passes to the page. Each keystroke triggers a keydown event carrying a key value (the logical key name), a code value (the physical key location), and modifier flags for Shift, Ctrl, Alt, and Meta. The display reflects those raw values, so you are seeing precisely what the browser received — not what an application might choose to interpret.

The KeyboardEvent interface has been stable in major browsers since 2016. The event.code property, which identifies the physical key location regardless of keyboard layout, was standardised in the UI Events specification and is supported in Chrome 48+, Firefox 44+, Safari 10.1+, and Edge 79+. If you are using a browser older than those versions, the physical key display may not work correctly, but event.key reporting should still function.

Common reasons to run a keyboard test include:

• Pre-purchase inspection — Test a second-hand keyboard before buying or immediately after receiving it
• Post-repair verification — Confirm a key replacement or membrane repair was successful
• Gaming readiness check — Verify WASD, spacebar, and hotkeys all register cleanly before a session
• Troubleshooting input issues — Isolate whether a problem is hardware, driver, or application-level
• Switch feel comparison — Confirm an aftermarket switch swap registers the same as the original
• RMA documentation — Gather evidence of a failing key before contacting a manufacturer for a warranty replacement
• N-key rollover verification — Confirm your keyboard correctly handles simultaneous key presses for fast typing or gaming

How to Test Your Keyboard in 3 Simple Steps

Step 1: Open the Tester in a Compatible Browser

Navigate to this page in a modern desktop browser. The Keyboard Event API is available in Chrome 48+, Firefox 44+, Safari 10.1+, and Edge 79+. Older browser versions may fail to report event.code correctly, which would cause the physical key location display to show as undefined. If you are on an older browser, updating it will resolve this.

No browser extension, plugin, or permission prompt is required. The page only listens for keyboard events fired within the browser window — it never accesses your system's global key log.

Step 2: Click Inside the Test Area and Start Typing

Click the keyboard tester input area to focus it, then press any key. Each key press will highlight the corresponding key on the on-screen layout and log the event details. Work through your keyboard systematically:

• Type the full alphabet (A–Z) one key at a time
• Press each number key across the top row (0–9)
• Test every symbol key: backtick, dash, equals, brackets, backslash, semicolon, apostrophe, comma, period, slash
• Press each modifier: Shift, Ctrl, Alt/Option, Cmd/Win, and Fn (where supported)
• Run through F1–F12
• Test navigation keys: Insert, Delete, Home, End, Page Up, Page Down, arrow keys
• Test the numpad if your keyboard has one

Step 3: Review the Results

Any key that does not highlight or log an event when pressed is either not registering or is being intercepted by the OS or browser before the page receives it. The section below on browser shortcut conflicts explains which keys are known to be unreachable.

After completing a full sweep of all keys, check the results against what you expect:

• Every key you pressed should have an entry in the log
• Keys you did not press should show no activity (if a key is logging events you did not press, that points to a stuck key or contact bridge)
• Modifier keys should appear as their own events before any combination events
• Key repeat events (held keys) should show repeat: true after the initial keydown

If you find a key that does not register, try pressing it multiple times with varying force. An intermittent result (sometimes registers, sometimes does not) is more useful diagnostic information than a simple pass/fail — intermittent failure usually indicates a mechanical or contact issue rather than a complete electrical open.

Compatible Keyboards

This tester supports any keyboard that the operating system presents to applications using the standard keyboard event interface. The following keyboard categories all work without any special configuration.

Mechanical Keyboards

Mechanical keyboards use individual switches under each key — common types include tactile (bump with no click), clicky (bump with audible click), and linear (smooth travel with no feedback). Every keyswitch type produces the same KeyboardEvent output regardless of actuation feel, so this tester works identically across Cherry MX Red, Brown, Blue, Gateron switches, Kailh variants, and all other standard MX-compatible designs.

Hot-swap boards, split layouts, 65%, 75%, TKL (tenkeyless), and full-size 104/105-key configurations are all supported. The on-screen layout adapts to show which keys are present on your physical board.

Keyboards with QMK or VIA firmware are also fully compatible — provided the active layer is sending standard USB HID key codes rather than macros or custom key codes. If you have programmed a layer where a physical key sends a macro sequence, the tester will display however the firmware reports that press to the OS, which may differ from what is printed on the keycap.

Popular mechanical keyboards this tester has been confirmed to work with include full-size boards from Ducky, Keychron, Leopold, Filco, and HHKB, as well as custom builds using PCBs like the DZ60, KBD75, and Tofu65.

Membrane Keyboards

Membrane keyboards use a pressure pad layer beneath a rubber dome to complete a circuit. They are the most common keyboard type shipped with desktop computers and bundled with office PCs from manufacturers like Logitech, Microsoft, Dell, and HP. Key feel is typically mushier than mechanical switches, but electrically they send identical USB HID signals.

If a membrane key stops registering, it is usually caused by a torn membrane layer under that key or contamination from a spill. This tester will confirm whether the issue is consistent or intermittent — an intermittent failure (key works sometimes but not others) usually points to a partially torn or dirty membrane rather than a fully failed circuit trace.

Membrane keyboards typically have lower N-key rollover than mechanical keyboards. Many ship with 6KRO, and budget models may have lower limits. If you type quickly and notice transposed characters or missing letters, test your keyboard's rollover with the simultaneous key press method described in the Ghosting and Key Rollover section.

Laptop Keyboards (Mac and Windows)

Built-in laptop keyboards connect over the internal PS/2 or proprietary bus but the OS presents their events to the browser in the same way as USB keyboards. MacBook keyboards (including the butterfly mechanism generation from 2016–2019 and the current scissor-switch Magic Keyboard design) and Windows laptop keyboards from Dell, HP, Lenovo, ASUS, and other manufacturers all work with this tester.

Laptop keyboards often omit numpad keys, the Insert key, and sometimes dedicated Home/End keys in favour of Fn-layer combinations. If a key on your laptop requires holding the Fn key, test the Fn+key combination rather than looking for the key standalone — the browser will see the resulting key code, not the Fn modifier itself (Fn is handled in firmware below the OS level on most laptop keyboards).

Wireless and Bluetooth Keyboards

Wireless keyboards — both RF 2.4 GHz dongles (Apple Magic Keyboard, Logitech Bolt, Unifying receiver) and Bluetooth (profile HID over GATT) — are fully supported. The radio link is transparent to the OS and browser; key events arrive the same way as wired input.

The one practical difference is latency. A wired USB keyboard typically adds 1–8 ms of input latency. A 2.4 GHz RF wireless keyboard is usually 2–10 ms, which is fast enough that most users cannot perceive it. Bluetooth keyboards vary more widely — typically 10–30 ms in normal operation with Bluetooth 4.0+ adapters, though older Bluetooth 3.0 devices or congested 2.4 GHz environments can push latency noticeably higher. This tester will not display raw latency figures, but if you notice a visible delay between pressing a key and seeing it register on screen, the wireless connection or a low battery is the likely cause.

Multi-device wireless keyboards:

Many modern wireless keyboards (Logitech MX Keys, Keychron K-series with Bluetooth) support pairing with multiple devices and switching between them with a button or key combination. If your keyboard stops responding to this tester, check that it is actively paired and connected to the current computer — a previously used pairing slot may have taken priority.

Keyboard sleep and wake:

Some wireless keyboards enter a sleep mode after a period of inactivity. The first key press after sleep is used to wake the keyboard and may not register as a key event in the browser. If the first key you press after a period of inactivity does not appear in the tester, press any key a second time — this is normal wireless keyboard behaviour.

If a wireless keyboard fails to register keys on this page but works in other applications, try re-pairing the receiver, replacing or recharging the battery, and moving the USB dongle away from USB 3.0 ports (which are a well-documented source of 2.4 GHz interference that can degrade wireless keyboard and mouse performance).

What the Keyboard Tester Checks

Individual Key Detection

Every key press fires a keydown event. This tester logs the event.key value (logical character, e.g. "a" or "Enter"), the event.code value (physical location, e.g. "KeyA" or "NumpadEnter"), and the timestamp. Pressing a key once should produce exactly one keydown event. If you see multiple events from a single physical press, the key contact is bouncing — a sign of a worn switch or contaminated membrane.

The difference between event.key and event.code matters for certain diagnostics. event.key reflects the current keyboard layout and modifier state — pressing the A key with Shift held will report "A" (uppercase), while without Shift it reports "a". event.code always reports "KeyA" regardless of modifiers or layout. If you have remapped your keyboard layout in software (for example, using the Dvorak or Colemak layout in OS settings), event.key will reflect the remapped character while event.code will still reflect the physical QWERTY position.

Key repeat events (keydown with event.repeat === true) begin after the OS key repeat delay (typically 500 ms on Windows, adjustable in macOS System Settings > Keyboard) and continue at the OS repeat rate (typically 30 per second on Windows, 25 on macOS by default). This is normal behaviour and not a keyboard fault. If you want to confirm a key is mechanically registering a single clean press, look for the initial keydown event with repeat: false.

Modifier Keys (Shift, Ctrl, Alt/Option, Cmd/Win)

Modifier keys are captured as standalone keydown events before any combination. Press Shift alone and the tester will show Shift registering. Then hold Shift and press A — you should see the key value become "A" (uppercase) while the code stays "KeyA".

Left and right variants of Shift, Ctrl, and Alt are tracked separately through event.code — "ShiftLeft" vs "ShiftRight", "ControlLeft" vs "ControlRight", "AltLeft" vs "AltRight". This matters for gaming, where some titles bind left and right Ctrl or Alt independently.

To thoroughly test modifier keys, check these scenarios:

• Left Shift alone — should register as key: "Shift", code: "ShiftLeft"
• Right Shift alone — should register as key: "Shift", code: "ShiftRight"
• Left Ctrl alone — key: "Control", code: "ControlLeft"
• Right Ctrl alone — key: "Control", code: "ControlRight"
• Left Alt alone — key: "Alt", code: "AltLeft"
• Right Alt alone — key: "Alt", code: "AltRight" (on Windows, this key is also AltGr on international keyboards and may produce an additional "AltGraph" key event)
• Cmd/Win alone — key: "Meta", code: "MetaLeft" or "MetaRight" depending on which key you press

If either the left or right variant of a modifier fails to register, the issue is specific to that physical key rather than the modifier function as a whole.

Function Keys (F1-F12)

Function keys send standard key codes ("F1" through "F12") unless the keyboard firmware or OS has remapped them. Many laptops default to multimedia actions (brightness, volume, mission control) on function keys, requiring the Fn key to reach the F1–F12 behaviour. Check your keyboard's Fn lock status or system settings if F-keys are not registering as expected.

On desktop keyboards, function keys are typically direct — pressing F5 sends "F5" without requiring Fn. On many laptop keyboards and some compact desktop keyboards, the default layer maps F1–F12 to media/brightness functions, and the actual F-key codes require Fn. Gaming keyboards often include a hardware Fn lock feature (sometimes indicated by a dedicated LED) that swaps which layer is the default.

Common function key browser shortcuts that are intercepted before reaching this tester:

• F1 — Opens browser help in some browsers; may not reach the page
• F5 — Refreshes the page, navigating away from the tester; use Ctrl+R instead for refresh so F5 can be tested
• F11 — Triggers browser fullscreen mode in most browsers, intercepting the event
• F12 — Opens browser developer tools in most browsers, intercepting the event

F2 through F4, F6 through F10, and F12 (when developer tools are not already open) should register without interference in Chrome and Firefox.

Numpad Keys

Numpad keys have distinct event.code values ("Numpad0" through "Numpad9", "NumpadAdd", "NumpadSubtract", "NumpadMultiply", "NumpadDivide", "NumpadDecimal", "NumpadEnter") that differ from the equivalent number row and symbol keys. This matters for applications that treat numpad Enter differently from main Enter, or numeric entry that distinguishes numpad digits from top-row digits.

Num Lock state affects what event.key reports — with Num Lock on, "Numpad7" reports "7"; with Num Lock off, it reports "Home". The event.code value remains "Numpad7" regardless. This tester shows both values, so you can confirm Num Lock is in the expected state and verify that numpad navigation keys (when Num Lock is off) all map to the expected directions and functions.

The full numpad secondary functions when Num Lock is off are:

• Numpad7 → Home
• Numpad8 → ArrowUp
• Numpad9 → PageUp
• Numpad4 → ArrowLeft
• Numpad5 → Clear (or undefined on some keyboards)
• Numpad6 → ArrowRight
• Numpad1 → End
• Numpad2 → ArrowDown
• Numpad3 → PageDown
• Numpad0 → Insert
• NumpadDecimal → Delete

If your workflow involves heavy numpad use for data entry, testing the numpad with Num Lock both on and off confirms that both modes work correctly.

Special Keys (Media, Print Screen, Scroll Lock)

Media keys (play/pause, stop, previous track, next track, volume up, volume down, mute) are supported by this tester when the browser exposes them. Chrome and Firefox both pass most media key events to the page. The exact event.key values are "MediaPlayPause", "MediaStop", "MediaTrackPrevious", "MediaTrackNext", "AudioVolumeUp", "AudioVolumeDown", and "AudioVolumeMute".

Note that some media keys trigger OS-level actions before the browser receives the event (for example, volume up on Windows changes the system volume immediately). The fact that the OS action occurs does not mean the key event reached the page — check the tester log to confirm.

Scroll Lock ("ScrollLock") and Pause/Break ("Pause") register in most browsers on Windows. They are rarely present on Mac keyboards. Caps Lock registers as "CapsLock" and lights the corresponding LED on keyboards that have one, but the LED state is managed by the OS, not the tester.

Print Screen behaviour varies by OS configuration. On Windows with default settings, pressing Print Screen alone captures a screenshot to the clipboard at the OS level and the key event may not reach the browser. Pressing Print Screen while this tester is in focus will confirm whether the event is passed to the page in your current OS configuration. On many Windows configurations, Alt+PrintScreen (active window capture) does reach the browser; plain PrintScreen does not. If PrintScreen does not register in this tester, that is expected OS behaviour rather than a keyboard fault — the physical key is working correctly even if the event is intercepted.

Windows key ("Meta") behaviour in Chrome and Firefox differs: Chrome intercepts some Win+key combinations at the OS level, while Firefox passes more of them to the page before the OS handles them.

Understanding Your Test Results

Key Not Registering

If a key produces no highlight and no log entry when pressed, there are several possible explanations:

1. Hardware failure — The switch, contact, or membrane under that key is not completing the circuit. Cleaning the key first (compressed air, keycap removal and contact cleaning with isopropyl alcohol) may resolve it. If the key fails consistently after cleaning, the switch or membrane section needs replacement.

2. Intermittent hardware contact — The key may register some of the time but not consistently. Press it rapidly 20–30 times and observe the hit rate. If it registers 18 out of 20 presses, the switch is wearing out but not yet fully failed. This kind of intermittent result is a reliable indicator that the switch is approaching end-of-life.

3. OS-level interception — Some key combinations are captured by the operating system before any application receives them. See the browser shortcut conflicts section below for a full list of keys that browsers cannot capture.

4. Driver or firmware issue — A keyboard with remappable firmware (QMK, VIA, or manufacturer software) may have a layer or macro assigned that prevents the default key code from reaching the OS. Check your keyboard software for accidental remaps. On QMK keyboards, verify the active layer with the layer indicator if your keyboard has one.

5. Browser focus lost — If you switch windows or click outside the tester area, the browser tab loses focus and key events stop firing. Click inside the tester area and try again.

Browser Shortcut Conflicts

Certain keys and combinations are intercepted at the OS or browser level and will never reach this tester. This is not a keyboard fault — it is a deliberate design of the OS and browser security model:

• Cmd+Q on macOS — Quits the active application immediately; the Q key event is never passed to the page
• Cmd+W on macOS — Closes the browser tab; the page is destroyed before it can log the event
• Cmd+H on macOS — Hides the current application; intercepted before reaching the page
• Cmd+Tab on macOS — Switches applications at the OS level
• Ctrl+Alt+Del on Windows — Intercepted by the Windows security layer (Winlogon); no application ever receives this combination, by design (it is the Secure Attention Sequence)
• Ctrl+Alt+Del equivalents — On some Linux desktop environments, similar secure attention key sequences behave the same way
• F11 in many browsers — Triggers the browser's own fullscreen toggle before the page event fires; the key event may not reach JavaScript at all
• PrintScreen on Windows — Captured by the OS screenshot mechanism in most default configurations; the browser page receives no event
• Win key on Windows — Opens the Start menu at the OS level; the page receives the keydown for "Meta" in some browser and OS version combinations, but not others
• Ctrl+T, Ctrl+N, Ctrl+W, Ctrl+Tab — Common browser tab management shortcuts; Chrome and Firefox both intercept these before the page event fires
• Alt+F4 on Windows — Closes the browser window entirely
• Ctrl+F — Opens the browser's find-in-page bar in most browsers, intercepting the event

If you need to verify whether these physical keys are mechanically functional (rather than logically reachable in the browser), the only reliable approach is to test them in a context where the OS shortcut does not apply — for example, temporarily disabling the shortcut in system settings, or testing in a text editor application where browser-level intercepts do not apply.

Ghosting and Key Rollover

Ghosting is a hardware limitation where pressing three or more keys simultaneously causes the keyboard to report a phantom fourth key that was never pressed. It is caused by the matrix scanning circuit in the keyboard controller, and it only affects certain key combinations determined by the keyboard's wiring layout. Ghosting is distinct from blocking (where the keyboard simply refuses to register additional keys) — ghosting produces false inputs while blocking just ignores the extra keys.

Key rollover is the number of simultaneous key presses a keyboard can correctly report. A keyboard with 2-key rollover (2KRO) can only register two keys at once. 6-key rollover (6KRO) is the maximum guaranteed by the USB HID boot protocol, which is why many non-gaming keyboards cap out at six simultaneous keys. N-key rollover (NKRO) means every key on the keyboard can be pressed simultaneously and all will register correctly.

To test your keyboard's rollover, press and hold multiple keys at once and observe how many register in the tester before additional presses stop appearing. A practical test sequence is to hold down A, S, D, F, G, H, J, K, L one at a time. If you can hold all nine and all appear registered, the keyboard has at least 9KRO for that key combination.

Most gaming mechanical keyboards advertise NKRO over USB. Many membrane keyboards are limited to 6KRO or less, and some budget boards drop to 2KRO. For competitive gaming involving fast key chords — quick-scoping, bunny hopping, or rhythm game patterns — NKRO or high rollover matters in practice.

Note that NKRO often requires a USB connection — some keyboards fall back to 6KRO over Bluetooth due to HID protocol limitations. If you primarily use your keyboard wirelessly, test rollover over both USB and Bluetooth connections to understand actual limits in each mode.

Troubleshooting Common Keyboard Issues

Keys Not Detected

Start with the simplest causes before assuming hardware failure:

1. Check the USB connection — Unplug and reconnect the cable. Try a different USB port. Avoid USB hubs if possible; connect directly to the computer's built-in port. Some USB hubs do not provide enough power for keyboards with per-key RGB lighting.
2. Restart the browser — Occasionally a browser tab loses keyboard focus. Close and reopen the tab, click inside the test area, and try again.
3. Check Fn lock — If function keys or numpad keys are behaving unexpectedly, the Fn lock state on your keyboard may have toggled without you noticing. Many keyboards indicate Fn lock with an LED or a label on the Fn key itself.
4. Test in another application — Open a text editor and type. If the key works there but not in the browser tester, the issue is browser focus or a tab shortcut conflict rather than hardware.
5. Try a different browser — If the key works in one browser but not another, it is a browser-level interception issue. Chrome and Firefox handle keyboard events with slightly different precedence rules for certain keys.
6. Check keyboard software — Software like Logitech G Hub, Corsair iCUE, SteelSeries GG, or Razer Synapse can remap keys at the driver level. Disable macros and verify the base layer is active.
7. Check Device Manager or System Information — On Windows, open Device Manager and confirm the keyboard appears under "Keyboards" without a warning icon. On macOS, open System Information > USB and confirm the keyboard is listed.
8. Try on a different computer — If the key fails on a second machine as well, the issue is definitively hardware. If it works on another computer, the problem is in the original machine's OS, drivers, or software.

Sticky or Delayed Keys

A key that registers late or fires repeated events may be suffering from:

• Debris under the keycap — Remove the keycap and clean with compressed air and a soft brush
• Switch lubrication migration — Over-lubed switches can cause sluggish actuation; cleaning and re-lubing resolves this
• Accessibility features — Windows Sticky Keys, Filter Keys, and Slow Keys can all alter key event timing. Check Settings > Accessibility > Keyboard and disable these if they are on
• Bounce / contact chatter — An aging switch may register multiple keydown events per physical press. This is a hardware issue; the switch needs replacement
• High CPU load — Under very heavy CPU load, the browser event loop can delay keydown processing. Test on a less loaded system to rule this out

Wireless Keyboard Lag

Noticeable lag between pressing a key and seeing it register can come from several sources:

• Low battery — Replace or recharge the battery. Wireless keyboards often exhibit increased latency when battery voltage drops below a threshold where the transmitter power reduces
• RF interference — USB 3.0 and 3.1 ports radiate broadband noise at 2.4 GHz and are a well-documented source of wireless peripheral interference. Move the USB receiver to a USB 2.0 port (usually the older, non-blue ports), or use a USB extension cable to position the receiver closer to the keyboard and away from USB 3.0 devices. This single change resolves wireless lag for many users.
• Bluetooth profile — Bluetooth Classic HID operates at lower latency than Bluetooth LE HID. If your keyboard offers a choice of Bluetooth profiles or a 2.4 GHz dongle mode alongside Bluetooth, the dedicated dongle typically provides lower and more consistent latency
• Operating system power management — Windows may put Bluetooth adapters into low-power states during periods of inactivity. In Device Manager, find your Bluetooth adapter under "Bluetooth", open Properties > Power Management, and uncheck "Allow the computer to turn off this device to save power"
• Crowded 2.4 GHz environment — If you are in an environment with many Wi-Fi networks (apartment buildings, offices), the 2.4 GHz band may be congested. Switching your Wi-Fi router to 5 GHz for nearby devices can reduce interference with wireless keyboard performance
• Keyboard to receiver distance — Most 2.4 GHz wireless keyboards are rated for 10 metres line-of-sight, but real-world performance through desks, monitor stands, and other equipment can reduce effective range. Position the USB receiver within 1–2 metres for optimal performance

Mac-Specific Issues

Option key combinations — On a Mac, Option (Alt) produces special Unicode characters when combined with letter keys (e.g. Option+E produces ´, Option+G produces ©). The browser reports these via event.key as the resulting character rather than the letter. This is expected behaviour — the event.code will still show the physical key location correctly, so you can confirm the Option key and the letter key are both functioning even if event.key shows a symbol.

Cmd key — The Command key maps to "Meta" in event.key. Some Mac keyboard shortcuts using Cmd are intercepted by macOS before reaching the browser (Cmd+Q quits the app, Cmd+H hides it, Cmd+Tab switches apps, Cmd+Space opens Spotlight), so these combinations will not register here. The Command key itself, pressed alone, does register as "Meta".

Globe/Fn key on Apple Silicon Macs — The Globe key in the bottom-left corner of Apple Silicon MacBook keyboards (replacing the Fn key) is handled at the OS level for emoji picker, dictation, and system shortcuts. It does not send a standard KeyboardEvent to web pages in most configurations.

Caps Lock delay on macOS — macOS applies a deliberate activation delay to the Caps Lock key to prevent accidental toggling. This means a very short tap on Caps Lock may not register as a key event in the browser because the OS did not process it as an intentional press.

Keyboard layout differences — Mac and Windows keyboard layouts differ slightly. The key to the left of Z is labelled differently, and some symbol placements vary between ISO (UK/European) and ANSI (US) layouts. If you are using a Windows keyboard on a Mac or vice versa, the event.code values will match the physical position, but event.key values may differ from what is printed on the keycap. This is normal and is not a keyboard fault.

Windows-Specific Issues

NumLock at login — Windows may reset NumLock state on login depending on your BIOS/UEFI setting and the Windows registry key that controls the initial NumLock state. If numpad keys behave unexpectedly after a fresh boot, check the NumLock state first.

Driver conflicts — Some keyboard manufacturers install driver software that intercepts key events before they reach the OS. If you suspect this, temporarily disable or uninstall the keyboard's companion software and retest. On Windows, you can see what keyboard-related drivers are running by checking Device Manager > Keyboards — if there is a vendor-specific entry alongside the standard HID entry, the vendor driver is active.

Language input method editors (IME) — If a Windows IME is active (for Chinese, Japanese, Korean, Arabic, or other languages requiring composition), key events during composition are handled by the IME rather than passed directly to the page. Characters being composed will not register as individual keydown events. Switch to direct input mode (usually the language bar or IME status icon in the system tray) to test individual key events accurately.

Filter Keys and Sticky Keys — These Windows accessibility features can cause keys to not register on short presses or to register multiple times. Confirm they are disabled in Settings > Ease of Access > Keyboard (Windows 10) or Settings > Accessibility > Keyboard (Windows 11) if you observe unusual behaviour.

Windows Game Mode and Game Bar — The Windows Game Bar shortcut (Win+G) is an OS-level intercept. Additionally, some Windows background services related to game mode can occasionally interfere with keyboard input routing. If you observe intermittent key drop behaviour during gaming, disable Game Mode temporarily to test.

AutoHotkey and similar remapping tools — If AutoHotkey or similar key remapping software is running, it may intercept certain key combinations before they reach the browser. Check the system tray for active remapping utilities if you see unexpected key behaviour.

Online Keyboard Tester vs Desktop Apps

Desktop keyboard testing utilities do exist — primarily QMK-based tools for firmware flashing, manufacturer-specific software like Logitech G Hub's key tester, and general input viewers like KeyboardTest or PassMark KeyboardTest. Each approach has trade-offs.

Online tester advantages:

• No installation, no administrator rights required
• Works the same way across Windows, macOS, and Linux
• Tests the full input stack from hardware through OS through browser — the same path key events travel in every web application
• No version to download or update
• Cannot be affected by conflicts with keyboard driver software (because it sits above the driver layer)
• Accessible from any computer, including borrowed machines, without leaving software behind

Desktop app advantages:

• Some desktop tools can intercept keys below the OS, capturing combinations like Ctrl+Alt+Del that browsers cannot see
• Low-level tools can report scan codes rather than interpreted key values, useful for firmware debugging
• Manufacturer software may display keyboard-specific metrics like actuation force curves
• Standalone executables continue working without a browser or network connection

Which to choose:

For the vast majority of use cases — verifying a key works, diagnosing a stuck key, checking rollover, confirming a repair — an online tester is faster and more convenient. You do not need to find and download a utility, and the browser approach tests the exact event path that all web-based input relies on.

For firmware development, low-level HID diagnostics, or testing OS-intercepted key combinations, a desktop tool that reads raw HID reports may be needed as a complement.

Complete Keyboard Testing Checklist

For a thorough keyboard test, work through this checklist in order. Check each group off as you verify it:

Letter keys (26 keys)

• [ ] A through Z — press each key individually; confirm all 26 register

Number row (10 keys)

• [ ] 1 through 0 — check both the digit and the shifted symbol for each key (!, @, #, $, %, ^, &, *, (, ))

Symbol keys

• [ ] Backtick/tilde (` and ~)
• [ ] Dash/underscore (- and _)
• [ ] Equals/plus (= and +)
• [ ] Left and right square brackets and braces ([ { and ] })
• [ ] Backslash/pipe (\ and |)
• [ ] Semicolon/colon (; and :)
• [ ] Apostrophe/quotation mark (' and ")
• [ ] Comma/less-than (, and <)
• [ ] Period/greater-than (. and >)
• [ ] Forward slash/question mark (/ and ?)

Modifier keys

• [ ] Left Shift and Right Shift (independently)
• [ ] Left Ctrl and Right Ctrl (independently)
• [ ] Left Alt and Right Alt/AltGr (independently)
• [ ] Left Cmd/Win and Right Cmd/Win (note: some keyboards have only one)
• [ ] Caps Lock

Function keys

• [ ] F1 through F12 (note expected intercepts for F5, F11, F12)

Navigation cluster

• [ ] Insert, Delete, Home, End, Page Up, Page Down
• [ ] Arrow keys (Up, Down, Left, Right)
• [ ] Backspace and Enter (both behave normally in the tester)
• [ ] Tab and Escape

Special keys

• [ ] Print Screen (may not register due to OS intercept — see above)
• [ ] Scroll Lock, Pause/Break

Numpad (if present)

• [ ] Numpad 0 through 9
• [ ] Numpad Enter (distinct from main Enter)
• [ ] Numpad +, -, *, /
• [ ] Numpad decimal (.)
• [ ] Num Lock

Rollover test

• [ ] Hold 6+ keys simultaneously and confirm all register

A keyboard that passes every item in this checklist is confirmed fully functional for all common computing and gaming tasks.

Keyboard Layouts and International Keyboards

This tester works with any keyboard layout configured in your operating system: QWERTY (US, UK, Australian, Canadian), AZERTY (French, Belgian), QWERTZ (German, Swiss, Austrian), Dvorak, Colemak, and others.

The event.code value always identifies the physical key by its QWERTY-equivalent position regardless of the active layout. For example, the physical key in the top-left of the letter area always reports "KeyQ" even if your layout maps it to "A" (as in AZERTY). The event.key value will reflect whatever character that key produces in your current layout.

This is useful for diagnosing layout-related input issues: if a key registers an unexpected character, check both the event.code (to confirm which physical key fired) and event.key (to confirm what the OS is reporting for that key in your current layout). A mismatch between what is printed on the keycap and what event.key shows indicates the OS keyboard layout setting does not match the keycap legends — not a keyboard hardware fault.

For ISO keyboards (common in UK, European, and Australian layouts), there is an extra key to the left of the Z key that ANSI keyboards lack. This key has the event.code value "IntlBackslash" and is fully supported by this tester. ANSI keyboards skip this key entirely, so this code will never appear on a US-layout physical keyboard.

Keyboard Maintenance Tips

Mechanical Keyboard Care

Mechanical keyboards reward regular maintenance. The switches themselves are rated for 50–100 million keystrokes depending on the manufacturer and model (Cherry MX rates their switches at 100 million, Gateron at 100 million, Kailh at 70 million for most variants), but accumulated dust and debris can degrade feel and increase actuation inconsistency well before switch wear becomes an issue.

Cleaning routine:

1. Unplug the keyboard before cleaning
2. Remove all keycaps with a keycap puller (available for a few dollars online) — use a wire keycap puller rather than a plastic ring puller to avoid scratching the keycap sides
3. Use compressed air at an angle to dislodge debris from between switches; hold the can upright to avoid spraying liquid propellant
4. Wipe the plate and PCB surface with a dry lint-free cloth or a cotton swab
5. For switches that feel rough or scratchy, consider re-lubing with an appropriate lubricant (PTFE-based lubes for linear switches, thinner lubes for tactile switches to preserve bump feel; avoid lubing the legs of tactile switches as this dulls the tactile bump)
6. Clean keycaps in warm soapy water, rinse thoroughly, and let dry fully (at least a few hours) before reinstalling — moisture under a keycap can cause corrosion on the switch top housing
7. Reconnect and run this tester to verify every key still registers after reassembly

How often to clean:

In a clean office environment, a full keycap-off clean every 6–12 months is reasonable. In dusty environments, near food preparation areas, or with heavy daily use, every 3–6 months may be appropriate. A quick compressed air pass without removing keycaps can extend the time between full cleans.

When to lube switches:

Factory-lubed switches lose lubricant over time and can become scratchy. Signs that re-lubing may help include increased switch noise, rough actuation feel, or increased wobble. Re-lubing does not void most keyboard warranties and is a standard maintenance practice in the mechanical keyboard community.

After any maintenance involving keycap removal, switch cleaning, or re-lubing, run a full keyboard test to verify no switch was accidentally dislodged or damaged during the process.

Hot-swap keyboards:

If your keyboard supports hot-swap switch replacement (a PCB socket system that does not require soldering), replacing a faulty switch is straightforward: use a switch puller to remove the old switch and press the replacement firmly into the socket, verifying the pins are not bent. Always test the new switch with this tester before reinstalling the keycap.

Membrane Keyboard Care

Membrane keyboards are less serviceable than mechanical boards, but basic cleaning extends their lifespan significantly. Most membrane keyboards cannot have individual rubber domes replaced without significant disassembly, so prevention is more important than repair.

Safe cleaning steps:

1. Unplug before cleaning
2. Turn the keyboard upside down and gently shake to dislodge loose debris — do this over a surface you can clean, as accumulated crumbs can be surprising
3. Use compressed air in short bursts at a low angle to clear crumbs and dust from between keys
4. Dampen (not wet) a microfiber cloth with a small amount of isopropyl alcohol (70% or higher) and wipe the keycap surfaces
5. For stubborn residue under keys, a cotton swab with isopropyl alcohol can reach between keys; press gently to avoid pushing debris further into the keyboard

Keycap removal on membrane keyboards:

Many membrane keyboards have removable keycaps, but the mechanism varies. Some use a simple friction fit (easy to remove with a thin keycap puller), while others have retaining clips that can break if pulled at the wrong angle. Check whether your specific keyboard model supports keycap removal before attempting — for low-cost membrane keyboards, the replacement cost may be lower than the risk of breaking the retaining mechanism.

Spill recovery:

If liquid spills on a membrane keyboard, act quickly. Unplug immediately, turn upside down to drain, and do not power on until the keyboard has dried for at least 24–48 hours. Sugary liquids (coffee with sugar, soft drinks) are more damaging than plain water because the residue leaves a conductive film on the membrane contacts when it dries. For sugary spills, flushing with distilled water (not tap water — minerals in tap water can leave residue), draining, and drying thoroughly gives the best recovery chance.

After any spill recovery, run this keyboard tester to identify which keys, if any, still have contact contamination. A key that sticks or doubles-registers after a spill usually indicates remaining sugar residue on the membrane contact surface.

Laptop Keyboard Care

Laptop keyboards are the hardest to service because of their integration with the chassis, but they are also used in environments — laps, desks, cafes, flights — that expose them to more debris and liquid risk than a desk keyboard.

Prevention:

• Keep liquids away from the keyboard area; even sealed lids on travel mugs can fail
• Avoid eating over the keyboard; crumbs work into the thin scissor-switch mechanisms and are difficult to remove
• Close the lid when transporting to prevent debris accumulation in the key gaps
• Consider a silicone keyboard cover for dusty or outdoor environments — they reduce tactile feel but protect well

Cleaning:

• Compressed air in short bursts at an angle dislodges debris from scissor switches; hold the laptop at a 75° angle while doing this to encourage debris to fall out rather than deeper in
• Isopropyl alcohol on a lint-free swab can clean individual sticky keys — apply to the swab, not directly to the keyboard
• Avoid silicone-based sprays or aerosol cleaning products — they can damage the plastic scissor retainer mechanism and may leave residue that attracts more dust
• For MacBook keyboards with the butterfly mechanism (2016–2019 models), Apple released a keyboard service program due to debris sensitivity. If you have one of these models with sticking keys, check if it qualifies for service.

When a laptop key is physically dislodged:

Most scissor-switch keycaps can be reattached by aligning the retainer clips with the scissor mechanism and pressing gently. The retainer is a cross-shaped or rectangular plastic frame that sits under the keycap; it must be seated correctly before the keycap will click back in. Check a resource or video specific to your exact laptop model before attempting this, as the retainer orientation and removal procedure varies significantly by manufacturer and model year.

MacBook keycap reattachment requires specific knowledge of the butterfly or scissor mechanism in use for that generation — Apple's service documentation is the most reliable reference.

After cleaning or reattaching keys, use this tester to verify each repaired key registers correctly, and confirm no adjacent keys were accidentally dislodged during the process.

Using This Tester for Gaming and Typing Workflows

Verifying a Gaming Keyboard Before Competitive Play

Before a competitive gaming session, a quick keyboard test can confirm your hardware is performing as expected. The most critical keys to verify for gaming are:

• WASD — Primary movement keys; any double-registration or missed input is immediately problematic in fast-paced games
• Space — Jump, confirm, or dodge action depending on the game
• Shift and Ctrl — Sprint and crouch; both left and right variants should be tested
• 1–5 or Q, E, R, F — Ability and weapon hotkeys
• Escape — Menu access; if this does not register, pause and menu navigation will fail

Run the rollover test (holding multiple keys simultaneously as described earlier) to confirm the keyboard can handle the simultaneous inputs that appear in fast play, such as moving and firing while crouching.

Confirming a New Keyboard Out of the Box

When receiving a new keyboard, running a complete key test takes about two minutes and gives you documented evidence of any dead-on-arrival keys before you have used the keyboard extensively. This is useful for:

• Determining whether a key was defective before it arrived or failed through use (relevant for warranty claims)
• Confirming the keyboard performs as specified before the return window closes
• Establishing a baseline so you can detect when a key starts degrading over time

Typing Speed and Key Registration

For touch typists and fast typists, the most relevant test is checking that all keys in your frequently used finger positions register reliably. If you type at 80+ WPM, the space bar, Backspace, Enter, and Shift keys see very high hit counts and are likely candidates for early wear. Testing these specifically after a period of heavy use can confirm whether wear is affecting registration before it impacts your typing noticeably.

Frequently Asked Questions

Does this keyboard tester work with any keyboard?

This tester works with any keyboard the operating system recognises as a standard USB HID or Bluetooth HID input device. That includes wired USB keyboards, wireless 2.4 GHz RF keyboards (using a USB dongle), and Bluetooth keyboards. Proprietary connection protocols that bypass the standard HID driver (rare in consumer keyboards) would not be testable here, but virtually all retail keyboards use standard HID and are fully compatible.

This includes keyboards with per-key RGB lighting, keyboards with media control wheels and displays, gaming keyboards with dedicated macro keys, 60% compact layouts, ergonomic split keyboards like the Kinesis Advantage and Ergodox, and standard full-size 104/105-key boards.

The only practical limitation is the browser: use Chrome 48+, Firefox 44+, Safari 10.1+, or Edge 79+ for correct KeyboardEvent.code support. On these browsers, both the logical key value (event.key) and the physical key location (event.code) will display correctly.

Can I test my laptop's built-in keyboard?

Yes. The built-in keyboard on any laptop — MacBook, MacBook Air, MacBook Pro, Dell XPS, HP Spectre, Lenovo ThinkPad, ASUS ZenBook, Microsoft Surface, or otherwise — is exposed to the operating system as a standard keyboard device. The browser receives its events identically to an external USB keyboard. You can test every key on your laptop keyboard with this tool.

The one caveat for laptops is the Fn key: Fn is handled in the keyboard controller firmware before the OS sees anything, so Fn itself will not appear as a keydown event in the browser. Keys that require Fn will register as their Fn-layer output (for example, Fn+F2 on a MacBook registers as the brightness-down media key rather than F2).

If you want to test the F1–F12 function key codes rather than the media key codes on a Mac, go to System Settings > Keyboard and enable "Use F1, F2, etc. keys as standard function keys." On Windows laptops, most manufacturers have a BIOS option to swap the default behaviour, or a physical Fn Lock key.

Why do some keys not register in the browser?

Some keys are intercepted at the OS level or by the browser before the page receives the event. The most common examples:

• Cmd+Q on macOS — Quits the app; never reaches the page
• Ctrl+Alt+Del on Windows — Handled by the Windows security layer
• F11 in many browsers — Triggers fullscreen mode at the browser UI level
• PrintScreen on Windows — Captured by the OS screenshot mechanism in many configurations

These are OS and browser design decisions, not keyboard faults. The physical key is functioning correctly even if it does not register in this tester.

Does this test work on Mac and Windows?

Yes. The Keyboard Event API is cross-platform. The main differences between Mac and Windows testing are:

• Mac keyboards label Option instead of Alt and Command instead of Win; the browser reports them as "Alt" and "Meta" respectively
• Some key combinations behave differently: Option+letter on Mac produces Unicode characters rather than a simple alt-modified event
• Certain OS-level shortcuts differ between platforms (Cmd+Q on Mac, Alt+F4 on Windows)

Beyond these differences, the test works the same way on both platforms.

How do I test if my keyboard has N-key rollover?

Open the tester, then press and hold keys one at a time without releasing any. Count how many keys you can hold simultaneously before additional key presses stop registering. If you can hold 6 keys and the 7th does not register, you have at least 6KRO. If every key you add continues to register regardless of how many you are holding, the keyboard has NKRO (or at least very high rollover for that key combination).

A practical test sequence for gaming rollover: hold down W, A, S, D (movement keys), then add Space (jump), Shift (sprint), Ctrl (crouch), and E (interact) one by one. This mimics a real gaming scenario. If all eight register, your keyboard handles common gaming input correctly.

Keep in mind that some keyboards switch from NKRO to 6KRO when connected via Bluetooth or when connected through a USB hub. For the most accurate result, test with a direct USB connection to a port built into the motherboard.

Is my keyboard data sent to any server?

No. This tester processes all key events locally within your browser tab using JavaScript. Key event data is never transmitted to any server, stored in any database, or shared with any third party. The KeyboardEvent objects are read by the page's JavaScript, used to update the visual display, and then discarded. You can verify this by monitoring network requests in your browser's developer tools (F12 > Network tab) while using the tester — you will see no outgoing requests related to key events.

This is an important distinction from some desktop keylogger-detection tools, which capture input at the OS level. This tester only sees events the browser itself receives — it cannot read events outside the browser window, and it does not access any system-level input stream beyond normal web page keyboard event handling.

What is the difference between event.key and event.code?

event.key is the logical value of the key — the character it produces in the current keyboard layout and modifier state. event.code is the physical identity of the key — where it is located on the keyboard, expressed as its QWERTY-layout equivalent position.

For example, if you have a Dvorak layout active and press the physical key in the QWERTY "A" position, event.key will report "a" (the Dvorak character for that position), while event.code reports "KeyA" (the QWERTY physical identifier).

For hardware testing purposes, event.code is the more reliable value — it tells you which physical key fired regardless of software layout. For diagnosing character output issues, event.key tells you what the OS is sending to applications.

Can I test a gaming keyboard's polling rate with this tool?

No. Polling rate (the frequency at which the keyboard reports its state to the OS, typically 125 Hz, 500 Hz, or 1000 Hz) is not directly measurable through browser KeyboardEvent data. The browser receives events when the OS passes them to it, and the OS does not expose raw polling rate information through the standard keyboard event interface.

To measure polling rate, a dedicated tool that reads raw USB HID reports is required. For practical gaming purposes, a 1000 Hz polling rate adds approximately 1 ms of potential input lag versus a 125 Hz rate (8 ms latency), which is only relevant in the most latency-sensitive competitive gaming scenarios.

Does the tester detect if I am pressing a key too softly to actuate?

No. This tester only receives events that the OS has already processed — meaning a keyswitch that actuated and sent a signal to the OS. Sub-actuation presses (where you press the key partway but do not reach the actuation point) produce no electrical signal and no event. If you press a key very lightly and it does not register, either the switch requires more force or your press did not reach the actuation distance.

For mechanical switches, actuation force ranges from approximately 35–45 g for light switches (like Gateron Yellow or Cherry MX Speed) to 60–80 g for heavy switches. If you regularly miss keypresses on a particular switch type, consider whether the actuation force is appropriate for your typing style.

Related Testing Tools

If you are testing other input hardware alongside your keyboard, these tools use the same browser-based approach — no downloads, no accounts, and all processing done locally in the browser:

• PS4 Controller Test — Test all buttons, analog sticks, triggers, and vibration on a DualShock 4 controller via the HTML5 Gamepad API. Covers all DualShock 4 hardware revisions and third-party PS4-compatible controllers.
• PS5 Controller Test — Test the DualSense controller including all face buttons, triggers, touchpad, and haptic feedback detection in supported browsers.
• Xbox Controller Test — Test Xbox One, Xbox Series X/S, and Xbox 360 controllers across all buttons, bumpers, triggers, and thumbsticks using the standard Gamepad API.

All three gamepad testers work with the HTML5 Gamepad API, supported in Chrome 21+, Firefox 29+, Edge 12+, and Safari 10.1+ (with varying levels of controller support by browser).

When to Use Multiple Input Testers

If you use a keyboard and controller together — for example, in a PC setup where you switch between mouse/keyboard and gamepad — testing both before gaming sessions confirms your entire input chain is functioning. Some PC games allow mixed input (keyboard movement with controller camera, for instance), making it useful to verify both input devices are responding as expected before starting.

Keyboard testing and gamepad testing complement each other because they exercise different browser APIs: keyboards use the KeyboardEvent interface while gamepads use the Gamepad API. Running both tests confirms that neither API has an issue receiving input in your current browser configuration.