---
title: "Spoof Browser Fingerprint Without Extensions and Verify It"
description: "Learn to spoof browser fingerprint without extensions using browser settings, DevTools overrides or an anti-detect browser. Then match IP and timezone."
url: "https://donutbrowser.com/es/spoof-browser-fingerprint/"
---

1. [Inicio](https://donutbrowser.com/es/)

2. [Blog](https://donutbrowser.com/es/blog)

3. Spoof Browser Fingerprint Without Extensions and Verify It

# Spoof Browser Fingerprint Without Extensions and Verify It

November 18, 2026

browser fingerprint anti-detect browser chrome devtools protocol

**You can spoof a browser fingerprint without extensions in three ways. Browser settings and hardened browsers suit people who want less tracking, DevTools or CDP overrides suit quick tests, and anti-detect browsers suit people who keep a separate identity for each account. Settings and DevTools change only values like the user agent, time zone, and screen size. Engine-level spoofing avoids the traces that page scripts leave, and each value you change has to match the rest.**

You want a different browser fingerprint, and you don’t want to install an extension. It’s for privacy-minded users who want less tracking, and for people who keep client, region or store identities apart. Those need profiles that stay separate.

Here’s how to spoof a browser fingerprint without extensions: you’ll pick a method, match the signals sites compare, and verify the result on test pages.

> **Key Takeaways**

> - Built-in settings and CDP overrides each change only part of the surface list, so neither covers canvas, WebGL, audio and fonts together.

> - A spoofed value that disagrees with your IP, timezone, language or GPU is easier to flag than your real one.

> - Use a stable value per profile for separate identities, and per-session randomization to reduce tracking.

> - A passing test page shows your signals agree. Platforms also weigh behavior and IP reputation, so no tool guarantees accounts avoid bans.

## How do you spoof a browser fingerprint without extensions?

You spoof a browser fingerprint without extensions by turning on built-in browser protections, sending DevTools or CDP overrides, switching to a hardened browser, or running an anti-detect browser that keeps one set of values per profile. The four differ in how many signals they change and whether you get one identity or several.

![Illustration for How do you spoof a browser fingerprint without extensions?](https://api.birchseek.com/m/oJI5TN-ySb-SsVAX_yUYn6KXNT4wGyp4.webp)

|  | Browser settings | DevTools/CDP overrides | Hardened browser | Anti-detect browser |
| --- | --- | --- | --- | --- |
| What it can change | A few signals, on or off | User agent, timezone, geolocation, screen | Several signals, browser-wide | A full set, per profile |
| Consistency | One fixed behavior | Gaps (canvas untouched) | One identity for all sites | Separate matched sets |
| Effort | Minutes | Redo each session | Switch browsers | Install, create profiles |
| Cost | Free | Free | Free | Free plan, paid tiers |

Built-in settings are the quickest test. In Firefox, type `about:config` in the address bar, search for `privacy.resistFingerprinting`, and toggle it to `true`. Then open a [fingerprint test page](https://donutbrowser.com/tools/browser-fingerprint) and compare the values before and after.

That preference applies to the whole browser. Every site sees the same setting, and you can’t give a second identity a different one.

DevTools and CDP overrides cover the values the protocol exposes. The Sensors panel overrides geolocation, and the Network conditions panel overrides the user agent.

These overrides reset when the session ends. They don’t touch canvas, WebGL or audio, so a mismatch between your user agent and your GPU stays visible.

Hardened browsers apply protections across the whole browser, which suits reducing tracking. Whatever you set applies to every tab, so you still have one identity.

An anti-detect browser keeps a separate set of values per profile. See [what an anti-detect browser is](https://donutbrowser.com/what-is-an-anti-detect-browser) for how profiles and cookie stores stay apart.

All four routes skip extensions because spoofing done by scripts injected into the page is easy to catch. Each one fits a different reader:

- **Browser settings:** a privacy-minded reader who wants less tracking in minutes.

- **DevTools/CDP overrides:** a developer checking how one page reacts to a different timezone or user agent.

- **Hardened browser:** someone who wants broader tracking protection with one identity.

- **Anti-detect browser:** someone running several clients, regions or stores whose profiles must stay apart.

## How do you spoof a browser fingerprint without extensions using settings and DevTools?

You change your fingerprint with the privacy settings built into Firefox and Brave, or with the Emulation domain of the Chrome DevTools Protocol (CDP). The browser settings change values across the whole browser, while CDP changes only four named values in one tab or session.

Start with the browser settings:

1. Open Firefox, enter `about:config`, accept the warning, search for `privacy.resistFingerprinting` and double-click it to set `true`. Reload your tabs.

2. Open Brave, click the lion icon, choose Advanced View and turn on fingerprinting blocking. Canvas noise can garble page graphics, so turn it off for a site that looks broken.

For DevTools and CDP, continue with these steps:

1. In Chrome DevTools, open the Command Menu and run “Show Sensors” or “Show Network conditions”. These panels send CDP Emulation commands for you.

2. Set the values you want.

3. Don’t expect canvas, audio, the WebGL renderer or fonts to change, because these CDP overrides don’t touch them. They still report your real hardware.

Then verify the result:

1. Reload the tab after each change, since overrides apply to new page loads.

2. Open the [free browser fingerprint test](https://donutbrowser.com/tools/browser-fingerprint/) and confirm that the timezone, language, user agent and location match what you set.

3. Check the canvas, WebGL and audio values on the same page. After the CDP route they should still match your real GPU and system. After Firefox or Brave protection they should differ from your first reading.

4. Compare the timezone against your IP location. A mismatch is a signal of its own.

## Why is spoofing in page JavaScript detectable, and what changes at the engine level?

Spoofing in page JavaScript is detectable because it replaces values the browser already defines, and the replacement leaves traces: changed property descriptors, functions whose `toString()` no longer shows native code, and gaps in iframes. Engine-level spoofing changes the value inside the browser, so the page finds no replaced function to inspect.

[MDN’s `getOwnPropertyDescriptor` reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor) says `Object.getOwnPropertyDescriptor()` “returns an object describing the configuration of a specific property on a given object”, so a page can check how `userAgent` is defined.

[MDN’s `Function.prototype.toString()` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString) also says the `toString()` method of a function “returns a string representing the source code of this function”. A genuine browser function prints `[native code]`, and a JavaScript replacement usually prints its own source.

A script patching the main page can also miss a fresh iframe. [Palant’s analysis of anti-fingerprinting extensions](https://palant.info/2020/12/10/how-anti-fingerprinting-extensions-tend-to-make-fingerprinting-easier/) calls the feature “almost universally flawed, potentially allowing even better fingerprinting.”

Manifest V3 adds a limit. [Chrome’s content scripts documentation](https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts) says content scripts live in an isolated world, so an extension must inject code into the page’s own context to change what the page reads. That puts the override where the page can inspect it.

You can run this check in your own console and read what comes back:

```
const own = Object.getOwnPropertyDescriptor(navigator, 'userAgent');
const proto = Object.getOwnPropertyDescriptor(Navigator.prototype, 'userAgent');
console.log(own, proto.get.toString());
```

A plain browser normally returns `undefined` for `own`, because the property lives on the prototype. A value defined on the instance, or a getter that prints JavaScript source instead of `[native code]`, suggests a script override.

Donut Browser’s [Wayfern engine](https://donutbrowser.com/docs/wayfern) changes values inside the browser instead.

Each profile looks like a different real device, not like every other user. Fingerprints for other operating systems need Pro, per [Donut Browser’s pricing page](https://donutbrowser.com/pricing).

To verify a profile:

1. Open the [free browser fingerprint test](https://donutbrowser.com/tools/browser-fingerprint) in it.

2. Check that user agent, platform, timezone, language and WebGL renderer describe one device.

3. Compare timezone and language with your proxy’s IP location.

4. Reload and confirm the values stay the same.

**Try the free browser fingerprint test** on one of your profiles.

## Which fingerprint surfaces should you spoof, and what does a leak look like?

Cover the ten surfaces sites read: navigator values, canvas, WebGL, audio, WebRTC, timezone, fonts, screen and window size, WebGPU and ClientRects. A leak is any value that contradicts another one or changes when it shouldn’t.

Fingerprint signals remain readable by any site without storing anything.

- **Navigator values** are the user agent, platform, language list, CPU core count and device memory. A leak is a Windows user agent next to a `MacIntel` platform, or a language list that disagrees with the proxy’s country.

- **Canvas** is the image a page draws off-screen and hashes. A leak is a hash that changes on every reload, or the same hash in two profiles that should look like different devices.

- **WebGL** reports the GPU vendor, renderer and parameters. A leak is a Mac user agent paired with a Direct3D renderer string.

- **Audio** is how the audio engine processes a test signal. A leak is a canvas hash that changed while the audio hash still matches your real machine.

- **WebRTC** can reveal addresses outside the proxy path. A leak is a local network IP or your real public IP showing up while the proxy IP shows everywhere else.

- **Timezone** is a named zone such as `America/New_York`, not only an offset. A leak is a named zone from a different city or country than the IP.

- **Fonts** are the typefaces a page can detect as installed. A leak is a macOS profile that lists Windows-only fonts, or a Windows profile with none of the usual ones.

- **Screen and window size** cover resolution, available area and the inner window. A leak is a window larger than the screen, or a desktop profile with a phone-sized screen.

- **WebGPU** is the newer graphics API. [MDN’s `GPUAdapterInfo` page](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo) says the interface “contains identifying information about a GPU adapter.” A leak is a WebGPU adapter that names a different GPU than WebGL does.

- **ClientRects** are element measurements from calls like `getBoundingClientRect()`, which depend on fonts and text rendering. A leak is measurements that don’t match the font list the profile claims.

Run the [canvas fingerprint test](https://donutbrowser.com/tools/canvas-fingerprint) and the [WebGL fingerprint test](https://donutbrowser.com/tools/webgl-fingerprint) to see the raw hashes and GPU strings a tracker would collect. The [guide to browser fingerprinting](https://donutbrowser.com/browser-fingerprinting) covers how sites combine these values.

## Which signals must match when you spoof a browser fingerprint without extensions?

A spoofed fingerprint is believable when IP location, timezone, language, geolocation, user agent, platform and WebGL renderer all describe the same person on the same device. Sites read these signals together, so one wrong value is enough to stand out.

[Donut Browser’s proxy guide](https://donutbrowser.com/proxies-for-anti-detect-browsers/) gives the lead case: a New York IP with an Asia/Ho\_Chi\_Minh timezone is flagged instantly. The same guide adds that matching only the UTC offset is not enough, because the browser exposes a named zone, so a Berlin proxy with a Prague timezone is still a mismatch.

You can reproduce this yourself. Route a profile through a New York proxy, set its timezone to `Asia/Ho_Chi_Minh`, and open a fingerprint test page. The IP location says New York while `Intl.DateTimeFormat().resolvedOptions().timeZone` returns `Asia/Ho_Chi_Minh`.

User agent spoofing has a second trap. [Chrome’s User-Agent Client Hints article](https://developer.chrome.com/docs/privacy-security/user-agent-client-hints) describes the API as a way to give developers browser information “in a privacy-preserving and ergonomic way”, and Chrome now sends a reduced User-Agent string.

[MDN’s `userAgentData` reference](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/userAgentData) says `navigator.userAgentData` returns an object for that API.

The proxy layer matters as much. Donut Browser doesn’t sell proxies, so the advice in our [proxy guide for anti-detect browsers](https://donutbrowser.com/proxies-for-anti-detect-browsers) is by trade-off. Choose the proxy’s region first, then set everything else to match it.

WebRTC can expose your real IP even behind a proxy, so run the [WebRTC leak test](https://donutbrowser.com/tools/webrtc-leak-test) on every profile.

Run this checklist for each profile:

1. Check the IP location on a what-is-my-ip page and note the city and country.

2. Set the timezone to a named zone from that location, such as `America/New_York`, not just a matching offset.

3. Set the browser language to one a person there would use.

4. Set geolocation to the same city, or deny the permission.

5. Change the User-Agent string and the UA Client Hints together, and confirm both agree.

6. Pick a platform and WebGL renderer that belong to the device you claim, such as an Apple GPU only on a Mac.

7. Confirm WebRTC shows the proxy IP or no local address.

## Should spoofed fingerprint values be random or stable?

A spoofed fingerprint value should stay stable when one profile must look like the same device on every visit, and change per session when the goal is to reduce cross-site tracking.

Canvas and audio spoofing add small noise to the data a page reads back. A site that draws to a canvas and then uses the result, such as a chart or a UI element, receives slightly altered data, so it can render wrong or fail a check.

You can see the effect on your own machine with the [canvas fingerprint test](https://donutbrowser.com/tools/canvas-fingerprint).

A value that changes on every page load causes a second problem. A real laptop doesn’t return a different canvas result each time it loads a page, so a site that reads the value twice and gets two answers has a signal.

Security researcher Wladimir Palant makes the same point in the title of his article, [“How anti-fingerprinting extensions tend to make fingerprinting easier”](https://palant.info/2020/12/10/how-anti-fingerprinting-extensions-tend-to-make-fingerprinting-easier/).

The rule follows from the purpose:

- **Several identities** (clients, regions, stores): give each profile its own value and keep it fixed, so it looks like the same device every time it returns.

- **Tracking reduction**: randomize per session.

Pick one approach per profile. Mixing them gives you the drawbacks of both.

## How do you verify that you spoof a browser fingerprint without extensions correctly?

Verify spoofing by testing your real browser first, changing one setting, and re-testing on the same pages, so every difference traces to a single change.

1. **Record a baseline.** Open every page below in your unmodified browser and save the values or a screenshot. Without it, you can’t tell what your spoofing changed.

2. **Run Donut Browser’s free test.** Open the [free browser fingerprint test](https://donutbrowser.com/tools/browser-fingerprint) and read the canvas, WebGL, audio, WebRTC, screen and hardware values. Check that the WebGL renderer fits the operating system in your user agent.

3. **Check BrowserLeaks.** Open its WebRTC page and confirm the IP shown is your proxy’s, not your home address. Then compare the canvas and WebGL values with your baseline. If you spoofed them, they should differ.

4. **Open CreepJS.** Look for consistency flags, meaning values that contradict each other, such as a Windows user agent with a macOS platform string. A contradiction usually means one value was changed and a related one was missed.

5. **Load Pixelscan.** Compare the IP location with the timezone and language, and confirm the named zone belongs to the IP’s city.

6. **Finish with EFF Cover Your Tracks.** Read the uniqueness result. A plausible spoofed device shouldn’t look rarer than your real browser, so a very rare result points to an odd combination of values.

7. **Change one setting, re-test, compare.** Change only the timezone, for example, then repeat steps 2 to 6 and compare with your notes. Changing several settings at once hides which one caused a new flag.

A pass proves your signals agree at that moment. It doesn’t prove more, because no test page can see a platform’s internal rules.

Repeat the routine after any proxy, OS or setting change. A new proxy can move your IP location away from the timezone you set, and an OS change can break the match between user agent and WebGL renderer.

## Frequently asked questions

### Is changing the user agent alone enough?

**No, because a user agent string is only one of several places a browser describes itself.** Sites also compare it with the platform, the Client Hints values, the GPU renderer and the screen size. A Windows user agent next to a macOS GPU renderer is a mismatch, and it stands out more than the default would.

### Will spoofing guarantee my accounts never get banned?

**No tool can guarantee that, and any tool that promises it is overselling.** Spoofing and isolation remove technical signals that link accounts, such as a shared fingerprint, shared cookies and a shared IP. Behavior, content and platform rules still decide bans, and those stay with you.

### Does blocking third-party cookies stop fingerprinting?

**No, because fingerprinting stores nothing in your browser.** A script reads values such as canvas output, fonts and screen size, then computes a hash from them. Run the [free browser fingerprint test](https://donutbrowser.com/tools/browser-fingerprint) with cookies blocked and the hash stays the same.

### Is canvas noise safe to leave on?

**Only for short tests, because random noise can garble drawn images and make you easier to spot.** A real device returns the same canvas result on every load, so a hash that changes each time is a signal itself. For a profile you reuse, a stable per-profile value avoids both problems. Check it on the [canvas fingerprint test](https://donutbrowser.com/tools/canvas-fingerprint).

## Next steps: set up and verify your fingerprint today

**Today:** Run the [free browser fingerprint test](https://donutbrowser.com/tools/browser-fingerprint) on your current browser and save the result as a baseline. Then pick your route: browser settings if you want less tracking, or separate profiles if you keep several identities apart.

**This week:** Change one setting or profile at a time. For each profile, match IP location, timezone, language and geolocation, then re-test.

**Ongoing:** Re-test after any proxy change, setting change or browser update.

This checklist works in any browser. If you want a ready way to spoof a browser fingerprint without extensions, download Donut Browser and run your first profile through the same test.

According to [Donut Browser’s pricing page](https://donutbrowser.com/pricing), the free plan has unlimited local profiles, needs no account, sends zero telemetry and is open source under AGPL-3.0. Our [privacy use case page](https://donutbrowser.com/use-cases/privacy) shows which settings suit tracking reduction.

## Sources

[Object.getOwnPropertyDescriptor() - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor) · [Function.prototype.toString() - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString) · [How anti-fingerprinting extensions tend to make…](https://palant.info/2020/12/10/how-anti-fingerprinting-extensions-tend-to-make-fingerprinting-easier/) · [Pricing - Donut Browser](https://donutbrowser.com/pricing) · [GPUAdapterInfo - Web APIs | MDN](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo) · [Proxies for Anti-Detect Browsers — Donut Browser](https://donutbrowser.com/proxies-for-anti-detect-browsers/) · [Improving user privacy and developer experience with…](https://developer.chrome.com/docs/privacy-security/user-agent-client-hints) · [Navigator: userAgentData property - MDN](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/userAgentData)

## Míranos más a menudo en Google

Con un clic, marcas Donut Browser como fuente preferida en tu cuenta de Google y es más probable que nuestros artículos aparezcan en tus Noticias destacadas, el Modo IA y las Vistas creadas con IA.

Prefiérenos en Google

## On this page

- How do you spoof a browser fingerprint without extensions?

- How do you spoof a browser fingerprint without extensions using settings and DevTools?

- Why is spoofing in page JavaScript detectable, and what changes at the engine level?

- Which fingerprint surfaces should you spoof, and what does a leak look like?

- Which signals must match when you spoof a browser fingerprint without extensions?

- Should spoofed fingerprint values be random or stable?

- How do you verify that you spoof a browser fingerprint without extensions correctly?

- Frequently asked questions

- Is changing the user agent alone enough?

- Will spoofing guarantee my accounts never get banned?

- Does blocking third-party cookies stop fingerprinting?

- Is canvas noise safe to leave on?

- Next steps: set up and verify your fingerprint today

- Sources
