Browser Brand Switching: Chrome, Edge, Brave Identity Control

Introduction

Every Chromium-based browser has a distinct identity defined by its brand tokens, User-Agent string, Client Hints headers, and navigator API values. Chrome, Edge, Brave, and Opera each present different brand information, version numbering, and feature surface despite sharing the Chromium engine. When your browser claims to be Edge but reports Chrome-specific brand tokens in Sec-CH-UA, the inconsistency is clear.

BotBrowser handles brand switching at the browser engine level. When you select a brand with --bot-config-browser-brand, all related signals update consistently: the User-Agent string, all Client Hints headers, navigator.userAgentData, brand token ordering, and version metadata all reflect the chosen brand. This article explains what brand switching controls, how to configure it, and why consistency across all brand signals matters.

Privacy Impact

Browser brand is a significant component of your browser's identity. Tracking systems use brand information to:

• Segment users by browser: Different brands have different user bases, demographics, and usage patterns
• Validate fingerprint consistency: A fingerprint that claims Chrome brand tokens but has Edge-specific navigator properties is suspicious
• Track brand-specific behaviors: Each brand has unique default settings, feature flags, and extension behaviors that affect the fingerprint

When brand signals are inconsistent, the mismatch itself becomes a tracking signal. A browser that reports Sec-CH-UA: "Microsoft Edge" but has navigator.userAgent containing "Chrome" without Edge-specific tokens is clearly misconfigured. This inconsistency is more distinctive than either brand alone.

BotBrowser ensures that when you select a brand, every signal associated with that brand aligns correctly. There are no partial updates or missed properties.

Technical Background

What Defines a Browser Brand

A browser's brand identity is expressed through multiple signals:

User-Agent string: The traditional User-Agent header and navigator.userAgent property. Each brand has a distinct format:

• Chrome: Mozilla/5.0 ... Chrome/142.0.7444.60 Safari/537.36
• Edge: Mozilla/5.0 ... Chrome/142.0.7444.60 Safari/537.36 Edg/142.0.3595.65
• Brave: Mozilla/5.0 ... Chrome/142.0.7444.60 Safari/537.36
• Opera: Mozilla/5.0 ... Chrome/142.0.7444.60 Safari/537.36 OPR/108.0.0.0

Client Hints (Sec-CH-UA): The Sec-CH-UA header contains brand tokens with version information. Each brand has a specific order and composition:

• Chrome: "Chromium";v="142", "Google Chrome";v="142", "Not:A-Brand";v="99"
• Edge: "Chromium";v="142", "Microsoft Edge";v="142", "Not:A-Brand";v="99"
• Brave: "Chromium";v="142", "Brave";v="142", "Not:A-Brand";v="99"

navigator.userAgentData: The JavaScript API that provides structured brand information:

navigator.userAgentData.brands
// Chrome: [{brand: "Chromium", version: "142"}, {brand: "Google Chrome", version: "142"}, ...]
// Edge:   [{brand: "Chromium", version: "142"}, {brand: "Microsoft Edge", version: "142"}, ...]

GREASE tokens: Chromium adds randomized "GREASE" tokens to Client Hints to prevent servers from depending on specific token formats. The GREASE token format and position vary by brand.

Version cadence: Chrome, Edge, and Opera release on different schedules. Chrome 142 may correspond to Edge 142 but with different patch versions. Opera has its own major version numbering. These version relationships must be correct for the brand to be credible.

Brand Token Ordering

The order of brand tokens in Sec-CH-UA and navigator.userAgentData.brands is important. Each brand has a specific, consistent order. Randomizing the order or using the wrong order is a mismatch signal.

BotBrowser maintains the correct brand token ordering for each supported brand, including proper GREASE token placement.

Common Approaches and Their Limitations

User-Agent String Override

Frameworks like Playwright and Puppeteer offer User-Agent override options:

// Playwright
const context = await browser.newContext({
  userAgent: 'Mozilla/5.0 ... Edg/142.0.3595.65'
});

// Puppeteer
await page.setUserAgent('Mozilla/5.0 ... Edg/142.0.3595.65');

These only change the User-Agent header and navigator.userAgent. They do not update:

• Sec-CH-UA headers (still report Chrome brand tokens)
• navigator.userAgentData.brands (still returns Chrome brands)
• Sec-CH-UA-Full-Version-List (still shows Chrome versions)
• High-entropy Client Hints values

The result is a clear mismatch between the UA string and Client Hints.

Client Hints Override via CDP

CDP provides Network.setUserAgentOverride which can set some Client Hints values. However:

• It requires Network.enable, which can affect fingerprinting behavior
• Not all Client Hints values are covered
• The override must be maintained per page and per worker
• Brand token ordering and GREASE token generation are not automatic

Extension-Based Brand Spoofing

Extensions that modify the User-Agent header face the same limitations as framework-level overrides. They cannot modify the values returned by navigator.userAgentData.getHighEntropyValues() because that API is implemented in native code, not in the JavaScript layer extensions have access to.

BotBrowser's Approach

The --bot-config-browser-brand Flag

BotBrowser's --bot-config-browser-brand flag (ENT Tier2) changes the browser's brand identity at the engine level:

# Launch as Microsoft Edge
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-browser-brand=edge

# Launch as Brave
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-browser-brand=brave

# Launch as Opera
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-browser-brand=opera

When you set the brand, BotBrowser updates all related signals:

Signal	Updated
User-Agent header	Yes
navigator.userAgent	Yes
Sec-CH-UA header	Yes
Sec-CH-UA-Full-Version-List	Yes
navigator.userAgentData.brands	Yes
getHighEntropyValues()	Yes
Brand token ordering	Yes
GREASE token format	Yes

Supported Brands

Brand	Flag Value	Notes
Chrome	chrome	Default Chromium-based identity
Edge	edge	Microsoft Edge with proper Edg/ token
Brave	brave	Brave browser identity
Opera	opera	Opera with OPR/ token
Chromium	chromium	Generic Chromium identity
WebView	webview	Android WebView (ENT Tier3)

Version Alignment

Each brand has its own version cadence. When switching to Edge, the Edge-specific version must align with the Chromium version. BotBrowser handles this automatically, but you can override with:

• --bot-config-brand-full-version: Sets the brand-specific full version (e.g., Edge's 142.0.3595.65)
• --bot-config-ua-full-version: Sets the Chromium full version (e.g., 142.0.7444.60)

These flags ensure UA-CH metadata stays internally consistent when a vendor's cadence diverges from Chromium's.

WebView Identity (ENT Tier3)

For Android WebView simulation, combine brand switching with custom User-Agent and platform settings:

chrome --bot-profile="/path/to/android-profile.enc" \
       --bot-config-browser-brand=webview \
       --user-agent="Mozilla/5.0 (Linux; Android {platform-version}; {model}) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/{ua-full-version} Mobile Safari/537.36" \
       --bot-config-platform=Android \
       --bot-config-platform-version=13 \
       --bot-config-model=SM-G991B \
       --bot-config-mobile=true

Placeholders like {platform-version} and {model} are replaced at runtime from the corresponding flags. BotBrowser auto-generates matching navigator.userAgentData and Client Hints headers.

Configuration and Usage

Basic Brand Switching (CLI)

# Edge identity with US proxy
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-browser-brand=edge \
       --proxy-server=socks5://user:pass@proxy:1080 \
       --bot-config-timezone=America/New_York \
       --bot-config-locale=en-US

# Brave identity with UK proxy
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-browser-brand=brave \
       --proxy-server=socks5://user:pass@uk-proxy:1080 \
       --bot-config-timezone=Europe/London \
       --bot-config-locale=en-GB

Playwright Integration

const { chromium } = require('playwright-core');

(async () => {
  const browser = await chromium.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      '--bot-profile=/path/to/profile.enc',
      '--bot-config-browser-brand=edge',
      '--bot-config-timezone=America/New_York',
      '--bot-config-locale=en-US',
    ],
    headless: true,
  });

  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://example.com');

  const brands = await page.evaluate(() =>
    navigator.userAgentData.brands.map(b => `${b.brand} v${b.version}`)
  );
  console.log('Brands:', brands);

  const ua = await page.evaluate(() => navigator.userAgent);
  console.log('UA:', ua);

  await browser.close();
})();

Puppeteer Integration

const puppeteer = require('puppeteer-core');

(async () => {
  const browser = await puppeteer.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      '--bot-profile=/path/to/profile.enc',
      '--bot-config-browser-brand=edge',
    ],
    headless: true,
    defaultViewport: null,
  });

  const page = await browser.newPage();
  await page.goto('https://example.com');

  const highEntropy = await page.evaluate(async () => {
    return await navigator.userAgentData.getHighEntropyValues([
      'fullVersionList', 'platform', 'platformVersion'
    ]);
  });
  console.log('High-entropy:', highEntropy);

  await browser.close();
})();

Multi-Brand Setup

Run different brands for different identities:

# Chrome identity
chrome --bot-profile="/profiles/chrome-user.enc" \
       --bot-config-browser-brand=chrome \
       --proxy-server=socks5://proxy-a:1080 \
       --user-data-dir="/tmp/chrome-session"

# Edge identity
chrome --bot-profile="/profiles/edge-user.enc" \
       --bot-config-browser-brand=edge \
       --proxy-server=socks5://proxy-b:1080 \
       --user-data-dir="/tmp/edge-session"

# Brave identity
chrome --bot-profile="/profiles/brave-user.enc" \
       --bot-config-browser-brand=brave \
       --proxy-server=socks5://proxy-c:1080 \
       --user-data-dir="/tmp/brave-session"

Verification

After launching with a brand override, verify these signals:

const page = await context.newPage();
await page.goto('https://example.com');

// Check User-Agent string
const ua = await page.evaluate(() => navigator.userAgent);
console.log('User-Agent:', ua);

// Check Client Hints brands
const brands = await page.evaluate(() =>
  navigator.userAgentData.brands.map(b => ({ brand: b.brand, version: b.version }))
);
console.log('Brands:', JSON.stringify(brands));

// Check high-entropy values
const highEntropy = await page.evaluate(async () => {
  return await navigator.userAgentData.getHighEntropyValues([
    'fullVersionList', 'platform', 'platformVersion',
    'architecture', 'bitness', 'model'
  ]);
});
console.log('High-entropy:', JSON.stringify(highEntropy));

Confirm that:

1. The User-Agent string contains the correct brand identifier (Edg/ for Edge, OPR/ for Opera)
2. Sec-CH-UA lists the correct brand tokens in the correct order
3. navigator.userAgentData.brands matches the HTTP-level Client Hints
4. High-entropy values like fullVersionList show the correct brand-specific versions
5. No Chrome-specific tokens appear when using a non-Chrome brand (unless the brand includes Chromium as a base token)

Best Practices

1. Keep versions aligned. When switching to Edge, use --bot-config-brand-full-version to set the correct Edge version that corresponds to the Chromium major version in your profile.

2. Match brand with regional usage patterns. Edge is more common in enterprise environments. Brave has a specific user demographic. Choose brands that align with the identity you are presenting.

3. Combine brand with matching proxy and locale. A complete identity includes brand, network, and geographic components.

4. Use profiles designed for the target brand. Some profile features may differ across brands. Using a profile captured from a real Edge browser with --bot-config-browser-brand=edge produces the most consistent results.

5. Test brand tokens with fingerprint verification tools. Verify that all brand signals align after configuration.

Frequently Asked Questions

Does brand switching change the browser's feature surface? Brand switching updates all identity signals (UA, Client Hints, navigator properties). Feature-level differences between brands (like Brave's shield or Edge's sidebar) are not emulated at the UI level, but the reported identity is consistent.

Can I use any brand with any profile? Yes. The --bot-config-browser-brand flag overrides the brand identity regardless of the profile's base configuration. CLI flags carry the highest priority.

What happens if I do not set --bot-config-browser-brand? The browser uses the brand specified in the loaded profile. If the profile does not specify a brand, Chrome is the default.

Does brand switching affect extension behavior? Brand switching changes identity signals, not the extension runtime. Extensions installed in the browser function the same way regardless of the configured brand.

Can I switch brands at runtime without restarting? No. The --bot-config-browser-brand flag is set at launch time. To change brands, launch a new browser instance with the desired brand.

What about GREASE token randomization? BotBrowser generates appropriate GREASE tokens for each brand. The GREASE format and position follow the patterns observed in real instances of each browser brand.

Is WebView brand switching different from other brands? Yes. WebView identity (ENT Tier3) typically requires additional flags for platform, model, and mobile settings to produce a complete Android WebView fingerprint. See the WebView section above for details.

Summary

Browser brand identity spans the User-Agent string, Client Hints headers, navigator APIs, brand token ordering, and version metadata. BotBrowser's --bot-config-browser-brand flag updates all of these signals consistently at the engine level, ensuring a complete and credible brand identity.

For User-Agent and Client Hints details, see User Agent Control and Client Hints. For combining brand identity with geographic settings, see Timezone, Locale, and Language Configuration. For multi-identity setups with different brands, see Multi-Account Browser Isolation.