Font Lists And Screen Sizes That Contradict A Profile
A screen that reports 1536 by 864 pixels looks like an odd number until you know where it comes from. It’s a 1920 by 1080 panel running at 125 percent Windows scaling, which is the default on a lot of laptops, and it reports a device pixel ratio of 1.25 to match. That combination is everywhere. Now take the same 1536 by 864 screen and pair it with a device pixel ratio of 1, a macOS font list and a user agent claiming Windows 11. Each value on its own is ordinary. Together they describe a machine that nobody owns. That’s the whole subject of this piece. Platforms rarely care about one font or one resolution. They care whether your signals agree with each other, and fonts and screens are where profiles most often argue with themselves.
Contradictions are the signal
Every fingerprint value has two kinds of weight. One is how rare it is. A common screen size tells a site very little, and an unusual one tells it more. The other is how well it fits with the rest. That second kind is the one people underrate.
Think about how a risk model sees the world. It has enormous amounts of real traffic, and in that traffic certain values travel together. Windows machines carry Windows fonts. MacBooks report a device pixel ratio of 2 on their built in displays. Phones report touch support and small, tall viewports. These pairings simply fall out of how real hardware and software ship.
A contradiction is a pairing that almost never occurs in real traffic. Its rarity is much higher than the rarity of either value alone, because each value is common and the combination isn’t. That’s why contradictions carry so much weight. They don’t narrow you down into a small crowd. They move you out of the crowd of real devices entirely.
Nobody outside a platform knows exactly how its model weighs each pair, and the models change. But the logic is standard in fraud scoring and it’s the same logic the open source spoof detectors use. Pick two signals that should agree, check whether they do, and add weight when they don’t. The rest of this piece is a tour of the pairs that break most often in antidetect profiles, and how to keep them in line.
How a site reads your fonts
A page can’t simply ask for a list of every font on your system. There’s a newer local font access interface in Chromium browsers, but it asks the user for permission first, so ordinary fingerprinting scripts don’t rely on it.
What they do instead is measure. The script renders a test string in a generic fallback font and notes its width and height. Then it renders the same string while requesting a specific font by name, with the fallback behind it. If the size changes, the requested font is installed. If it doesn’t, the browser fell back, so the font is missing. Run that against a list of a few hundred font names and you have a good picture of what’s installed, without any permission prompt. A related check uses the browser’s own font loading interface to ask whether a given font is available.
The resulting list is a portrait of the machine’s history. The operating system contributes its base set. Language packs add fonts for other scripts. Office suites, design software and some games add their own. Two machines with the same OS and nothing else installed look similar. After a year of ordinary use they diverge.
For an antidetect profile, that means the font list has two jobs. It has to belong to the operating system the profile claims. And it has to look like a plausible machine, which usually means a base set plus some ordinary additions rather than a bare minimum or a kitchen sink.
What each operating system brings
This is where the most common contradiction lives, so it’s worth being specific.
Windows ships with its own family of system fonts. Segoe UI is the interface font. Calibri, Cambria and Consolas are very widely present, partly through Office. Arial, Times New Roman, Courier New and Verdana are there too, along with a set of symbol fonts.
macOS brings a different set. The San Francisco system fonts, Helvetica Neue, Menlo and Monaco for code, Apple’s emoji font, and a long list of others that don’t exist on Windows by default. Some names overlap, like Arial and Times New Roman, because both vendors license them. Those shared names tell a site little. The platform specific ones are the tell.
Linux desktops lean on open font families like DejaVu, Liberation and Noto, with the exact set depending on the distribution. Android uses Roboto and Noto families. iOS uses Apple’s.
So a profile claiming Windows 11 that reports Helvetica Neue and Menlo, and doesn’t report Segoe UI, is a Mac presenting itself as Windows. A profile claiming a Mac that reports only DejaVu fonts is almost certainly a Linux server. A simple rule catches this kind of contradiction, no statistics needed.
Language packs matter too. A profile claiming a Japanese speaking user with no Japanese fonts installed is unusual. A profile claiming an English speaking user in Singapore with a full set of Chinese fonts is perfectly normal, since plenty of people there read both. Fonts should fit the person as well as the machine.
When the font list and the rendering disagree
There’s a second layer to fonts that trips up antidetect tools even when the list itself looks right.
The list is what the measurement test reports. But the pixels that actually get drawn come from whatever fonts the host machine has. If a tool spoofs the list, telling the page that Segoe UI is installed on a Mac host, the measurement test may be fooled, depending on how the spoof works. Meanwhile any text the page draws in “Segoe UI” is actually drawn in some other font the host has, because the real font isn’t there.
A careful script can notice. It measures text width in a font the profile claims to have, then compares that to the known metrics of the real font. Segoe UI has particular letter widths. If the measured width matches a different font’s metrics, the claimed font isn’t real.
The same problem shows up in emoji. Each operating system has its own emoji font, with different shapes and sizes. A page that draws an emoji and measures it, or reads it back as pixels, can tell which system emoji font drew it. A Windows profile drawing Apple emoji is a contradiction that font list spoofing doesn’t touch.
Good tools deal with this by shipping or loading the real fonts for the claimed OS where licensing allows, or by keeping claims close to what the host actually has. Weaker tools only edit the list. The practical takeaway is simple. The safest font list is the one the host really has, which means the safest claimed OS is usually the host’s own.
The screen numbers a page can read
The screen gives a page more separate numbers than most people realise, and they’re related to each other in ways that make contradictions easy to spot.
There’s the screen width and height, in CSS pixels. There’s the available width and height, which is the screen minus anything the operating system reserves, like the Windows taskbar or the macOS menu bar and dock. There’s the device pixel ratio, which says how many physical pixels sit behind each CSS pixel. There’s colour depth. Then there’s the browser window itself: the inner width and height of the page area, and the outer width and height of the whole window including tabs and toolbars.
Some of those numbers are also readable through CSS media queries, which a page can evaluate from script. Queries about screen width, pixel ratio, whether the main pointer is fine or coarse, and whether hovering is possible all return answers that should match the JavaScript values.
Each of these on its own is weak. A 1920 by 1080 screen is so common it tells a site almost nothing. What makes the screen useful to a fingerprinting script is the set of relationships between the numbers, which is exactly what the next section covers.
How screen numbers relate to each other
Here are the relationships that hold on real machines.
The window can’t be larger than the screen, at least not in normal use. An inner width wider than the screen width suggests the screen value was faked and the window wasn’t.
The available height is usually a little smaller than the screen height. On Windows, a visible taskbar takes a strip off the bottom. On macOS, the menu bar takes a strip off the top, and the dock may take more. A Windows profile where available height equals screen height isn’t impossible, since some people auto hide the taskbar. But it’s less common, and a whole fleet of profiles all doing it is a pattern.
The outer window is larger than the inner window by the height of the browser’s own toolbars. That difference depends on the browser and the OS. A Chrome window with zero difference between outer and inner height looks like a headless browser or a stripped automation window.
Screen size multiplied by device pixel ratio gives the physical panel resolution. That’s the 1536 by 864 example from the start. At a ratio of 1.25 it works out to a 1920 by 1080 panel, which is common. At a ratio of 1.5 it works out to 2304 by 1296, which isn’t a panel anyone sells in volume. A spoof that sets both values independently can easily land on a physical resolution that doesn’t exist.
MacBook built in displays report a ratio of 2 by default. A MacBook profile with a ratio of 1 is either on an external monitor or a spoof.
The laptop with a workstation GPU
Screen size carries an implication about the device class, and the graphics card reported through WebGL carries another. They have to be compatible.
A 1366 by 768 screen belongs mostly to older and cheaper laptops. A profile reporting that screen next to a top end desktop graphics card is describing an entry level laptop with a card that doesn’t fit in one. Could someone plug a budget laptop screen into a gaming desktop? In theory. In real traffic that combination is rare enough to weigh.
The same logic applies to CPU core counts and memory figures the browser reports. An entry level laptop reporting a very high core count, or a phone reporting desktop memory, adds another mismatch.
This is one of the places where antidetect profiles built from random templates go wrong. The tool picks a GPU from one list, a screen size from another and a core count from a third, each drawn independently. Each choice looks fine alone. The combination is incoherent.
The fix is to think in terms of one real device. Pick a plausible machine, like a mid range Windows laptop from the last few years, and ask what that machine would report for every value. A 1920 by 1080 panel at 125 percent scaling, an integrated or modest discrete GPU, a moderate core count, Windows fonts plus Office. Then make the profile say all of that, and nothing else.
The smaller screen values
Beyond size and pixel ratio, a page can read a handful of smaller screen facts, and each one has to fit the claimed device as well.
Colour depth is usually 24 on ordinary desktops and phones. Some Macs with wide colour displays report 30. A value outside the common ones is rare enough to notice.
Screen orientation is readable too. A desktop monitor reports landscape almost always. A phone reports portrait most of the time and flips when rotated, and its reported width and height swap with it. A phone profile that never rotates is fine, since plenty of people never turn their phone. A phone profile whose orientation says portrait while its width is larger than its height is a contradiction.
Touch support is the one that catches Windows profiles out in both directions. Plenty of Windows laptops have touchscreens, so a Windows profile reporting touch points isn’t strange by itself. But touch support should sit on a laptop class screen with a laptop class GPU, not a large desktop monitor with a workstation card. And a claimed phone with zero touch points is simply impossible.
Newer Chromium versions also let a page ask whether the screen is part of a multi monitor setup. The answer is only a yes or no without extra permission, but it has to agree with the rest. A profile claiming a phone that reports an extended desktop is contradicting itself.
None of these is a big signal. Each is one more pair that a coherent device keeps in step without trying and a stitched together profile can get wrong.
A phone viewport on a desktop OS
The mobile contradiction is the one people hit when they try to make a desktop browser look like a phone.
Resizing a desktop browser window to a tall, narrow shape, or setting a mobile user agent, doesn’t make it a phone. A real phone reports a small screen in CSS pixels with a high device pixel ratio, often 2 or 3. It reports touch support with several touch points. Media queries say the primary pointer is coarse and hover isn’t available. Its fonts are Android or iOS fonts. Its screen orientation can be portrait or landscape, and the screen dimensions swap when it rotates.
A desktop browser pretending to be a phone typically gets some of these right and misses others. It might report a phone sized viewport with a ratio of 1, no touch points and a fine pointer. It might report Windows fonts. Its WebGL renderer names a desktop card. Every one of those is a contradiction with the claimed device.
Developer tools in Chrome have a device emulation mode that fixes several of these at once for testing. It’s designed for web developers checking layouts, not for hiding anything, and it leaves plenty of desktop evidence in place.
If an account genuinely needs to look like a phone, the honest approach is to use a phone. For web accounts that don’t need that, a desktop profile that looks like an ordinary desktop is far better than a desktop wearing a phone costume.
Real people have odd setups too
It would be easy to read all of this and conclude that any unusual value is a problem. It isn’t, and it’s worth saying why, because overcorrecting creates its own tell.
Real people plug laptops into external monitors, so the screen size changes between sessions. They zoom the browser, and in Chrome, zooming changes the reported device pixel ratio. They hide their taskbar. They install fonts for a single design project and forget about them. They run Windows in a virtual machine on a Mac. Some of them use remote desktop sessions with strange resolutions.
A risk model that punished every one of these would drown in false positives, and platforms can’t afford to annoy their real users like that. So a single oddity is usually weighed lightly. What pushes a score is a contradiction that has no ordinary explanation, or several oddities stacked on one profile, or the same oddity repeated across many accounts.
That last point matters for fleets. One profile reporting an unusual screen size is a person with an unusual monitor. Fifty profiles reporting the same unusual screen size, the same font list and the same missing taskbar look like one template. The contradiction checks and the cluster checks work together.
So the target is a profile with the ordinary texture of a real machine. That includes the odd font someone installed once. Scrubbing everything to a perfect minimum looks nothing like a real machine either.
Stability over time matters as much
Contradictions between signals are one axis. Contradictions across time are the other, and they catch a different kind of mistake.
A real laptop reports the same fonts today as it did last week, give or take an occasional install. Its built in screen reports the same size and ratio every session. When it’s docked to an external monitor, the screen values change to the monitor’s, and they change back when it’s undocked. That’s a small set of states the device moves between.
A profile that randomises its screen size every time it launches has no such pattern. On Monday it’s a 1366 by 768 laptop, on Tuesday a 2560 by 1440 desktop, on Wednesday a 1440 by 900 Mac screen. No physical device behaves like that. Neither does a font list that grows and shrinks between sessions.
Some tools include a setting that regenerates parts of the fingerprint on each launch, sold as extra protection. For an account you intend to keep, it does the opposite. The account’s device history becomes a string of different machines, and a platform that remembers which devices an account logs in from sees a new one every day.
The safer pattern is one device per profile, fixed at creation, and changed only on purpose. If you do need to change a profile’s device, for example after the tool updates its engine, change it once and let it settle, the way a person who buys a new laptop logs in from it every day afterwards.
Keep a note in your profile records of the device each profile claims. It makes this kind of drift easy to spot, and it makes the next profile easier to set up without accidentally copying the last one.
A worked audit of one profile
Here’s a hypothetical profile, built quickly from a tool’s random template, to show how the checks work in practice.
The user agent claims Chrome on Windows 10. The font list includes Arial, Times New Roman, Helvetica Neue, Menlo and Apple Color Emoji, with no Segoe UI. The screen reports 1366 by 768 at a pixel ratio of 1, with available height equal to screen height. The inner window is 1880 pixels wide. WebGL names a high end desktop card. Touch points read zero.
Walk through it pair by pair. Windows with Mac only fonts and no Segoe UI is the first contradiction, and the loudest. It says the host is a Mac. A 1366 wide screen with an 1880 wide window is the second, since the window can’t be wider than the screen. That says the screen value was edited and the window wasn’t. Available height matching screen height on Windows is a mild oddity. A budget laptop screen with a top end desktop card is a third contradiction.
So one profile carries three clear contradictions and one oddity. Any one of them could have an innocent explanation in a real person’s life. Three together don’t.
Now fix it by starting from the host. The host is a Mac, so the profile claims a Mac. The fonts are real. The screen becomes the MacBook’s own built in values, with a pixel ratio of 2 and a menu bar strip off the available height. The window sits inside the screen. WebGL shows the Mac’s real GPU with seeded noise. There’s nothing left to argue with, because every value is the machine telling the truth about itself.
Where the host leaks through
Most contradictions in real profiles don’t come from bad settings. They come from the host machine showing through the parts the tool doesn’t cover.
Media queries are a common gap. A tool may override the JavaScript screen values while the CSS media queries still report the host’s real screen and pixel ratio. A page that checks both sees two different screens.
Window sizing is another. If the profile claims a 1366 by 768 screen and the actual browser window on your 27 inch monitor is 2000 pixels wide, the inner width gives the game away. Some tools resize the window to fit the claimed screen. Some don’t. Maximising a window on a large monitor can push it past the claimed screen size.
Fonts, as covered above, often leak through rendering even when the list is spoofed.
Iframes and workers can also expose values from a slightly different context. If the tool patches the main page but not every context, a script can read the same value twice and get two answers.
None of these need you to understand the tool’s internals. They need you to test the profile the way a site would, which means checking the values against each other rather than one at a time.
Checking a profile in fifteen minutes
Here’s a routine for the font and screen layer specifically. It fits alongside any broader profile check you already run.
Open the profile and load a fingerprint checker that lists detected fonts. Scan the list for the platform specific names. A Windows profile should show Segoe UI and the Office fonts if you’ve claimed Office is installed. It should not show Helvetica Neue, Menlo or any San Francisco font. A Mac profile should show the reverse.
Load a page that draws emoji, or look at the emoji on any website. Ask whether they look like the claimed system’s emoji or the host’s.
Then check the screen block. Write down screen width and height, available width and height, device pixel ratio, inner and outer window size. Confirm the window fits inside the screen. Confirm the available height is a bit smaller than the screen height. Multiply the screen size by the pixel ratio and check the result is a real panel resolution. Confirm outer is larger than inner.
Load a checker that shows media query results, or one that compares the JavaScript and CSS answers, and confirm they agree.
Finally, open two or three other profiles and repeat the screen check. If they all report exactly the same unusual numbers, vary them.
Keep the results in your profile log, with the date.
Building a profile that agrees with itself
Putting it together, here’s how I’d set up the font and screen layer for a new desktop profile.
Start from the host. If you’re on Windows, claim Windows. If you’re on a Mac, claim a Mac. Claiming the host’s own operating system removes the biggest source of font contradictions, because the fonts on the machine are the fonts the profile claims.
Pick one plausible device for the profile and write it down. Something like a mid range laptop with a 1920 by 1080 panel at 125 percent scaling. Every other value then follows from that choice: a screen of 1536 by 864, a ratio of 1.25, a GPU that fits a laptop, a core count that fits the GPU’s class.
Let the window sit inside the claimed screen. If your tool doesn’t resize windows to fit, don’t maximise profile windows on a monitor larger than the claimed screen.
Leave a realistic font list. The OS base set plus a few ordinary additions is closer to real life than a bare list.
Vary the device choice across profiles, among common options. A fleet where half the profiles are the same laptop model is still plausible, since laptop models sell in huge numbers. A fleet where every profile has the same exact values down to the window height is a template.
And keep each profile’s device stable over time. A person’s laptop doesn’t change its screen and fonts every week.
The honest limit
Getting fonts and screens consistent takes away a set of easy contradictions. It doesn’t make a profile invisible, and it doesn’t protect an account that has other problems.
I can tell you which pairs of values real devices keep in step, because that follows from how operating systems and hardware ship. I can’t tell you exactly which pairs a given platform checks, or how heavily each is weighted today. Nobody outside those platforms can. The public spoof detectors show what’s possible, and any serious platform can do at least as much.
What consistency buys you is simple to state. A profile whose signals agree with each other only has to answer the questions every real device answers. A profile full of contradictions starts every session already explaining itself.
The network under the profile still has to agree with it too. A Singapore profile with a Singapore time zone and Windows fonts still falls apart on a datacenter address from another continent. Fonts and screens are one layer of a story that has to hold together from the hardware up through the IP address to the way the account behaves.
I run Singapore mobile proxy and cloud phone farms myself, so the identities I care about most sit on real devices whose fonts and screens are honest because the hardware is. If you want the rest of the consistency picture, from time zones to proxy choice, start on the Multi Account Ops home page.
Get new guides and videos first — join the Telegram channel.