← back to blog

Keyboard layout fingerprint: what your typing gives away in an anti-detect browser

Most fingerprinting writeups stop at canvas, WebGL, fonts, and audio context. Those get talked about constantly because they’re easy to demo. Keyboard layout and input method signals get almost no attention, and that’s exactly why they’re worth understanding. They sit below the browser, in the operating system’s input subsystem, which means the usual profile-spoofing tricks in anti-detect browsers often don’t reach them at all.

If you run multiple browser profiles for multi-accounting, this is one of the places where a profile can look geographically consistent on paper (right IP, right timezone, right Accept-Language) and still leak a mismatch the moment someone actually types into a form.

What a page can read before you type anything

Before a single keystroke happens, a page already has three pieces of language-adjacent data:

  • navigator.language and navigator.languages, JS-readable and usually derived from OS or browser locale settings.
  • The Accept-Language HTTP header, sent with every request.
  • Intl.DateTimeFormat().resolvedOptions().timeZone and related Intl locale data, which expose timezone and formatting conventions (date order, decimal separator, currency format).

None of this involves a keyboard yet. It’s the baseline that a fraud or bot-detection script cross-references against IP geolocation. If the IP resolves to Germany but Accept-Language says en-US and the timezone reads America/New_York, that’s a mismatch worth flagging on its own, keyboard aside. Anti-detect browsers are generally built to keep these three in sync, and that part is table stakes at this point.

The signal that starts once you type: KeyboardEvent.code vs .key

Here’s where it gets interesting. Every KeyboardEvent in a browser carries two different values:

  • code: the physical key that was pressed, identified by its position on the keyboard, independent of layout. Pressing the key to the right of Tab on a US keyboard always reports KeyQ, even if that key produces a different character on an AZERTY or QWERTZ layout.
  • key: the actual character or logical value produced, which depends entirely on the active keyboard layout and modifier state.

On a real US QWERTY keyboard, pressing KeyQ produces key: "q". On a real French AZERTY keyboard, that same physical position produces key: "a", because AZERTY moves the letters around. A script that logs both values during a form fill can compare them against what’s expected for a given locale. If a profile claims to be a French user (French Accept-Language, Paris timezone, French IP) but every keystroke maps code to key in a pattern that only makes sense on a US layout, that’s a concrete, checkable inconsistency, not a guess.

This is a real, standard part of the DOM event object. It’s used in games and productivity apps to detect physical key positions regardless of layout, and it’s just as usable by anyone watching input events on a login or checkout form.

The Keyboard Map API

Chromium-based browsers also expose a more direct API: navigator.keyboard.getLayoutMap(). Called from a focused, secure context, it returns a map from physical key codes to the characters the current layout assigns them, essentially handing a script the entire layout table without needing you to type first. It’s gated by browser support (Chromium only, not in Firefox or Safari as of this writing) and by secure-context and interaction requirements, so it isn’t universally available on every page. But where it is available, it’s a direct read of the OS-level keyboard layout, which is a much cleaner signal than inferring layout from a handful of keystrokes.

This is a good example of why the “physical layer” framing matters: this API is reading real OS input configuration, not something the browser process itself decides. Overriding what it reports means intercepting or rewriting the API’s output, not just changing a language dropdown in a browser profile UI.

IME and composition events

For scripts that aren’t Latin-alphabet based, typing usually goes through an Input Method Editor: Pinyin for Chinese, Hangul input for Korean, kana-to-kanji conversion for Japanese. The DOM fires a distinct set of events for this: compositionstart, compositionupdate, and compositionend, separate from the regular keydown/keyup/input sequence.

A profile that claims to be a native speaker of a CJK language but produces no composition events at all, and instead just fires direct single-character keydown events, is behaving like someone pasting text or typing on a Latin keyboard rather than someone actually using an IME. That’s another checkable gap between claimed identity and actual input behavior, and again, it’s not something a browser’s spoofed navigator.language value fixes, because it depends on whether an actual IME session ran on the host OS.

Typing cadence and keystroke dynamics

Separate from layout entirely, some fraud and anti-bot systems, particularly in banking and account-security contexts, log the timing between keystrokes: dwell time (how long a key is held) and flight time (the gap between releasing one key and pressing the next). Real human typing has irregular, personally consistent rhythm. Form fields populated by autofill, clipboard paste, or scripted input tend to produce timing that’s either instantaneous or suspiciously uniform. This is a behavioral signal, not a configuration one, so it doesn’t map neatly onto anything a browser profile setting controls. It’s worth knowing about because it’s part of the same broader category: signals generated by the act of typing itself, not by headers or JS properties a tool can rewrite.

Where anti-detect browsers help, and where the layer changes

Tools like Multilogin, GoLogin, Kameleo, AdsPower, and Dolphin Anty operate mainly at the browser and JS-engine level: they manage separate cookie and storage containers per profile, control Accept-Language headers, adjust the JS-reported timezone, and in varying degrees patch or randomize canvas, WebGL, and font enumeration output. That covers the layer a page can query passively, before any interaction happens.

Keyboard layout and IME behavior sit one level down, in how the operating system maps physical key presses to characters and composition sessions. A profile-level setting that changes what navigator.language reports doesn’t change what keyboard layout is actually active on the machine doing the typing, and it doesn’t make an IME session happen if one didn’t. Closing that particular gap means the OS-level input configuration actually matching the profile’s claimed locale, which is a different problem than anything a browser extension or profile manager solves by itself.

None of this makes any of these tools undetectable or a guarantee against a ban. It means the signals a detection script can gather span more than the browser fingerprint properties that usually get discussed, and a profile that’s internally consistent at the browser level can still be inconsistent at the input level.

Practical takeaway for profile consistency

If you’re building out profiles for multi-accounting work, the useful habit is treating keyboard layout as part of the same consistency check you already run for timezone, language, and IP geolocation. A profile that claims a locale should have its actual typing behavior, physical keyboard layout, and (where relevant) IME usage line up with that locale rather than defaulting to whatever layout your own machine happens to run. That’s a matter of testing your own setup against the KeyboardEvent properties and composition events described above, using your browser’s own developer console, rather than assuming a language dropdown in a profile manager covers it.

We test this kind of signal hands-on because it’s the sort of gap that only shows up once you actually look at what a page can read, not from a vendor’s feature list.

Want more breakdowns like this, grounded in how detection actually works rather than marketing claims? Head back to the Anti-Detect Review homepage for the rest of our browser tests and fingerprinting explainers.

Get new guides and videos first — join the Telegram channel.

need infra for this today?