Keyboard Layout & Language Fingerprinting: The Locale Mismatch Most Teams Miss

11 min read

Picture a profile with a US proxy, a US timezone and a US locale. The person using it types on a Ukrainian layout, and navigator.languages still reads ['uk-UA', 'ru-RU', 'en-US'] because nobody touched it.

That profile argues with itself. Proxy, clock and locale point to one place. Input method and language list point to another. Locale consistency matters for QA, regional testing, and understanding what your profile actually represents. When signals disagree, it's worth understanding why and fixing it so the profile matches your intended use case.

This tutorial covers what pages can read about keyboard and language, why the signals should align for your profile's intended purpose, and how to check a JustBrowser profile for consistency. That's essential for QA across regions, accurate regional testing, and agencies working in client accounts in markets they're testing from.

One caveat before we start. This is about internal consistency and understanding what pages can read. It isn't a way around any platform's enforcement. If an account has been restricted, a locale setting won't change that, and the platform's own appeal route is the only real fix.

Prerequisites

  • JustBrowser installed. The 7-day trial (card required) gives you unlimited profiles to test with.
  • A working proxy. Any provider, as long as you know the country and the main language expected there.
  • About 15 minutes.

If you haven't set timezone and geolocation yet, do that first. Keyboard and language settings sit on top of clock and coordinates.

Step 1: Understand what a page can read

Three separate things carry your input locale. Sites that care can compare all three.

1. KeyboardEvent.code and KeyboardEvent.key. A keydown event has two properties that people constantly mix up. code is the physical key position and doesn't change with layout. key is the character that press produced, and that is what changes.

Take the key in the Y position on a US keyboard. On US QWERTY it reports code: "KeyY" and key: "y". On a German QWERTZ keyboard, the same physical key is printed Z, so it reports code: "KeyY" and key: "z". The code is identical. Only key moved. On a Russian layout, that same press has code: "KeyY" and key: "н".

So a page doesn't learn your layout from code alone. It learns it from the pairing of the two. A code of KeyY producing "н" while the IP says Kansas is the unusual combination.

2. navigator.languages. This property returns your preferred languages in priority order. Someone in Munich typically has ['de-DE', 'de', 'en-US', 'en']. Someone in Chicago has ['en-US', 'en']. Browsers also expose navigator.language, which is just the first entry.

3. The Accept-Language header. Requests carry this header, built from the same list. Servers see it before any script runs. A request from a US IP with Accept-Language: ru-RU,ru;q=0.9,en-US;q=0.8 is a mismatch anyone logging requests can read. Traffic-quality tooling can compare it with the IP's location.

Pages can also look at pasted text. Cyrillic characters arriving in a field expose the script you type in, whatever the configured layout says.

This is an often-overlooked locale signal. Many developers focus on canvas hashes. Few verify their own Accept-Language header matches their profile's location.

Step 2: Decide what the profile's locale should be

Before touching a setting, write down one line: this profile belongs to a person in country X who types in language Y. Every field should follow from that sentence.

The layout is where people trip. Pick the layout the person actually types on. If the profile is a German market profile operated by someone who types QWERTZ, great. If it's operated by someone on a US keyboard, a US layout is the honest answer, and the language list should reflect a user who speaks German but types on a US board. Some real people do exactly that.

The hard rule: the keyboard and the language list describe a real human. Don't invent a layout you don't type on. You'd produce garbled input and an even stranger signal than the one you were trying to fix.

Check the profile's settings directly and confirm which input-locale fields the version you're running exposes, rather than assuming a layout field exists with a particular name. The app is the source of truth, and the verification steps below don't depend on it.

Step 3: Set the language list

Open the profile and find its language and locale settings. The list should follow a simple pattern: region-specific locale first, then the base language, then English as a common fallback.

US:

['en-US', 'en']

Germany:

['de-DE', 'de', 'en-US', 'en']

France:

['fr-FR', 'fr', 'en-US', 'en']

Japan:

['ja-JP', 'ja', 'en-US', 'en']

English in the list isn't suspicious. Plenty of non-English speakers keep it as a fallback for international sites.

Four things make a list look inconsistent:

  • Your own language first when it doesn't match the profile's location (the ['uk-UA', 'ru-RU', 'en-US'] case)
  • English only for a market where that's rare (['en-US'] for a German IP)
  • Reversed order (['en-US', 'de-DE'] reads as an American, not a German)
  • Languages with no geographic logic (['ja-JP', 'pt-BR', 'sw-TZ'])

Set it once per profile and it persists across sessions. Get this wrong and perfect canvas settings don't help.

Step 4: Verify Accept-Language

The header is built from the language list, but verify rather than trust.

Launch the profile and visit a header-inspection page such as httpbin.org/headers, or open the Network tab in DevTools and click any request. You want something like:

Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7

The q= values are quality weights. The first language has an implicit weight of 1.0 and the rest step down.

If the header doesn't match what you configured, the likeliest cause is that the profile wasn't fully stopped and restarted after the change. Close it completely, relaunch, check again.

The server-side angle is the reason to bother. The header arrives with the very first request, before a line of JavaScript runs, so a mismatch with the IP is visible immediately. Checking it takes seconds.

Step 5: Look at key events yourself

You can see exactly what a page sees. Open the console (F12, then Console) and paste:

document.addEventListener('keydown', (e) => {
  console.log('key:', e.key, 'code:', e.code);
});

Click into the page and press a few keys. On a US QWERTY layout, the key in the Y position logs key: y, code: KeyY, and the key in the Z position logs key: z, code: KeyZ.

On a German QWERTZ layout, the key in the Y position logs key: z, code: KeyY, and the key in the Z position logs key: y, code: KeyZ. The code column never changes. The key column swaps.

What you're checking is that the characters coming out match the language you set in Step 3. A German profile whose keys produce Latin QWERTY output isn't necessarily wrong (see Step 2), but you should know that's what it is.

For automation users: when profiles are driven through the local REST API with Playwright or Puppeteer, keep in mind that synthetic key events sent over CDP carry whatever key and code your script specifies. Make sure your script's input matches the locale you chose for the profile.

Step 6: Cross-check with a public inspection page

Don't trust a single check. These show what any website can read from the profile. Use them to confirm consistency, not as a score to chase.

  1. BrowserLeaks. Its JavaScript section shows navigator.language and navigator.languages. Confirm values and order match the location.
  2. A header check. httpbin.org/headers confirms Accept-Language against your settings.
  3. The key-event snippet from Step 5.

If any of them disagree with the sentence you wrote in Step 2, fix the profile before real work begins. The JA4 TLS fingerprint guide covers the network-level counterpart, since language signals and TLS signals are read side by side.

Run the checklist whenever you create a profile. It's tedious. Skipping it is worse.

Common problems and fixes

Cause: The profile wasn't fully restarted after you changed the language settings.

Fix: Stop the profile in JustBrowser (the profile itself, not just the window) and start it again. Language settings apply when the profile initialises.

Key events don't match what you expected

Cause: You're typing on a different physical keyboard than the one you assumed, or the operating system's input source differs from what you planned.

Fix: Look at the key column from Step 5 and compare it with your intended language. Then check the OS input source on the machine you're typing on. If they're correct and the profile still looks off, create a fresh profile with the same settings to rule out a bad one.

Accept-Language is empty or malformed

Cause: Some automation frameworks strip or override headers.

Fix: With Playwright or Puppeteer, don't set custom headers that replace Accept-Language. Without automation, look for conflicting extensions in the profile.

Pasted non-Latin text stands out

Cause: You're pasting Cyrillic, Arabic or Chinese text into a profile whose location and language list say otherwise.

Fix: That isn't a settings problem. It's an operational one: the person doing the work uses a script the profile doesn't claim. If you need to type Russian, build the whole profile around it: a Russian-located proxy, a Cyrillic layout and a matching language list. Anything less is a contradiction you created yourself.

The profile looks consistent but a site still treats it differently

Cause: Language and keyboard are two signals among many. Timezone, WebGL renderer strings or proxy location may disagree.

Fix: Check those too. And if an account has been restricted, use the platform's own appeal process; no browser setting resolves that.

Next steps

Aligned keyboard and language signals close one of the subtler inconsistencies. Not the flashiest fingerprint surface, since nobody writes conference talks about KeyboardEvent.code, but it matters for QA and regional testing.

For the wider location-consistency picture, also cover:

Describe the person first, then make every field agree with the description.

Frequently Asked Questions

Why does keyboard layout matter for browser fingerprinting?

KeyboardEvent.code reports the physical key position and is the same on every layout, while KeyboardEvent.key reports the character that key produced. Pages that watch both can infer which layout you type on. A US IP address paired with Cyrillic characters coming out of the keys is unusual, so it is one more locale signal a site can weigh.

How does navigator.languages ordering reveal a mismatch?

navigator.languages returns an array of preferred languages in priority order. A German user typically has ['de-DE', 'de', 'en-US', 'en']. If the IP geolocates to Germany but the array starts with 'en-US', the two signals disagree. Order matters as much as the values.

What is the Accept-Language header and how does it relate to location?

Accept-Language is an HTTP header sent with requests to say which languages the browser prefers, and browsers build it from the same language list as navigator.languages. A header like 'ru-RU,ru;q=0.9,en-US;q=0.8' arriving from an IP in Texas is a contradiction a server can see without running any JavaScript.

Can a page see which keys I press?

Only while the page has focus and you interact with it. Key events carry both code and key, and pasted text exposes its script. Nothing is visible outside the page. The practical advice is to make the profile's configured locale match the way you actually type.


Try JustBrowser

A multi-account browser for teams on a custom Chromium engine — not extension-based. Real C++ engine patches at the canvas / WebGL / audio / font / screen layer, with 40+ identity parameters, patched on every upstream Chromium release. Local REST API + CDP for Playwright, Puppeteer, Selenium. 7-day free trial, card required — then $9.99/month or $99.99/year, unlimited profiles, free team seats.

Get started → · How it differs from Multilogin / GoLogin / AdsPower

Ready to manage multiple accounts?

Seven days free, then $9.99/month — one plan, everything included.

We'd like to use Google Analytics, a Google service, to understand how our website is used. It sets two cookies in your browser and runs only if you click Accept. You can change your choice at any time with Cookie settings. Cookie Policy

Sign-in cookies and the cookie that remembers this choice are always on; the website needs them to work.

Google Analytics, a Google service, helps us understand how our website is used. It sets two cookies, _ga and _ga_TVZHQ99TZW. It is now onoff in this browser. If your browser sends a Global Privacy Control or Do Not Track signal, it stays off. Cookie Policy