Extra Stealth Mode

Anchor Browser provides built-in stealth capabilities that help avoid detection by anti-bot systems and website fingerprinting. These features enable automated browsing that mimics human behavior and bypasses common detection mechanisms. Extra Stealth mode is available on the Growth plan.

What is Extra Stealth Mode?

Extra Stealth Mode leverages a specialized Chrome browser environment that provides:

🔒 Advanced Anti-Detection - Bypass sophisticated bot detection systems and CAPTCHAs
🛡️ Automation Consistency - Maintain consistent access without getting blocked
👤 Human-Like Behavior - Mimic real user patterns to avoid suspicion

Alternative Cloudflare-verified access to webpages is available through our Cloudflare Web Bot Auth Integration.

Quick start - Enable stealth features

Create a session with extra stealth enabled

Create a browser session with extra stealth features enabled using the SDK:

Extra stealth mode requires proxy configuration to be active. If proxy is disabled, extra stealth will be automatically disabled by the system.Read more about Proxy Configuration

import { client, Sessions } from "anchorbrowser";

client.setConfig({ auth: () => process.env.ANCHOR_API_KEY })
const session = await Sessions.createSession({
    body: {
        browser: {
            extra_stealth: {
                active: true
            }
        },
        session: {
            proxy: {
                active: true
            }
        }
    }
});

console.log(session);

from anchorbrowser import Anchorbrowser
import os

anchorClient = Anchorbrowser(api_key=os.getenv("ANCHOR_API_KEY"))
session = anchorClient.sessions.create_session(
    browser={
        "extra_stealth": {
            "active": True
        }
    },
    session={
        "proxy": {
            "active": True
        }
    }
)
print(session)

Use the session for automated browsing

Once your stealth session is created, you can use it for automated browsing that bypasses common detection mechanisms:

import { client, Sessions, agentTask } from "anchorbrowser";

client.setConfig({ auth: () => process.env.ANCHOR_API_KEY })
 
// Create stealth session
const session = await Sessions.createSession({
    body: {
        browser: {
            extra_stealth: {
                active: true
            }
        },
        session: {
            proxy: {
                active: true
            }
        }
    }
 })

// Use the session for automated tasks
const result = await agentTask(
    "Navigate to a website and check if I'm detected as a bot",
    {
        sessionId: session.data.id
    }
);

console.log(result);

from anchorbrowser import Anchorbrowser
import os

anchorClient = Anchorbrowser(api_key=os.getenv("ANCHOR_API_KEY"))

# Create stealth session
session = anchorClient.sessions.create_session(
    browser={
        "extra_stealth": {
            "active": True
        }
    },
    session={
        "proxy": {
            "active": True
        }
    }
)

# Use the session for automated tasks
result = anchorClient.agent.task(
    session_options=session,
    prompt="Navigate to a website and check if I'm detected as a bot"
)

print(result)

Using stealth with tasks

Save stealth settings on the task via task_default_browser_configuration — a one-time setup. Include browser.extra_stealth and an active session.proxy (required):

curl -X PATCH "https://api.anchorbrowser.io/v1/tools/{toolId}" \
  -H "anchor-api-key: $ANCHOR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "task_default_browser_configuration": {
      "browser": { "extra_stealth": { "active": true } },
      "session": { "proxy": { "active": true } }
    }
  }'

If you pass a session_id to /run, that session’s config is used instead. See Run a Task.

Usage with Profiles

Use stealth mode with saved browser profiles for persistent authenticated sessions:

import { client, Sessions } from "anchorbrowser";

client.setConfig({ auth: () => process.env.ANCHOR_API_KEY })
const session = await Sessions.createSession({
    body: {
        browser: {
            extra_stealth: {
                active: true
            },
            profile: {
                name: 'stealth-profile',
                persist: true   // Only on Profile Creation
            }
        },
        session: {
            proxy: {
                active: true
            }
        }
    }
})
console.log(session)

from anchorbrowser import Anchorbrowser
import os

anchorClient = Anchorbrowser(api_key=os.getenv("ANCHOR_API_KEY"))
session = anchorClient.sessions.create_session(
    browser={
        "extra_stealth": {
            "active": True
        },
        "profile": {
            "name": "stealth-profile",
            "persist": true   # Only on Profile Creation
        }
    },
    session={
        "proxy": {
            "active": True
        }
    }
)
print(session)

Enabling Console Logs

When extra stealth mode is enabled, page.on('console') events are disabled by default to prevent detection. If you need to capture console output, you must explicitly enable it.

To receive console log events while using extra stealth, enable console_logs in your session configuration:

import { client, Sessions, connectBrowser } from "anchorbrowser";

client.setConfig({ auth: () => process.env.ANCHOR_API_KEY });

const session = await Sessions.createSession({
  body: {
    browser: {
      extra_stealth: { active: true },
      console_logs: { active: true }
    },
    session: {
      proxy: { active: true }
    }
  }
});

// Connect to the browser
const browser = await connectBrowser(session.data.id);
const context = browser.contexts()[0];
const page = context.pages()[0];

// Now page.on('console') will work
page.on('console', (msg) => {
  console.log(`[${msg.type()}] ${msg.text()}`);
});

await page.goto("https://example.com");

from anchorbrowser import Anchorbrowser
import os

anchor_client = Anchorbrowser(api_key=os.getenv("ANCHOR_API_KEY"))

session = anchor_client.sessions.create_session(
    browser={
        "extra_stealth": {"active": True},
        "console_logs": {"active": True}
    },
    session={
        "proxy": {"active": True}
    }
)

# Connect to the browser
with anchor_client.browser.connect(session.data.id) as browser:
    context = browser.contexts[0]
    page = context.pages[0]

    # Now page.on('console') will work
    def handle_console(msg):
        print(f"[{msg.type}] {msg.text}")

    page.on("console", handle_console)

    page.goto("https://example.com")

Catching Captcha Events

When using stealth mode with captcha solving enabled, you can listen to captcha lifecycle events via CDP (Chrome DevTools Protocol). This allows you to track when captchas are detected, solved, or failed.

import { client as anchorClient, Sessions, connectBrowser } from "anchorbrowser";

anchorClient.setConfig({ auth: () => process.env.ANCHOR_API_KEY });

// Create a session with extra stealth and captcha solving enabled
const session = await Sessions.createSession({
  body: {
    browser: {
      extra_stealth: { active: true },
      captcha_solver: { active: true }
    },
    session: {
      proxy: { active: true }
    }
  }
});

// Connect to the browser
const browser = await connectBrowser(session.data.id);
const context = browser.contexts()[0];
const page = context.pages()[0];

// Create CDP session and listen to captcha events
const client = await context.newCDPSession(page);

client.on('Captcha.lifecycle', (event) => {
  if (event.name === 'detected') {
    console.log(`${event.captchaType} captcha detected on ${event.url}`);
  }
  
  if (event.name === 'solved') {
    console.log(`Captcha solved in ${event.timeToSolve}ms`);
  }

  if (event.name === 'failed') {
    console.log(`Captcha failed: ${event.error}`);
  }
});

// Navigate to a page with captcha
await page.goto("https://example.com");

from anchorbrowser import Anchorbrowser
import os

anchor_client = Anchorbrowser(api_key=os.getenv("ANCHOR_API_KEY"))

# Create a session with extra stealth and captcha solving enabled
session = anchor_client.sessions.create_session(
    browser={
        "extra_stealth": {"active": True},
        "captcha_solver": {"active": True}
    },
    session={
        "proxy": {"active": True}
    }
)

# Connect to the browser
with anchor_client.browser.connect(session.data.id) as browser:
    context = browser.contexts[0]
    page = context.pages[0]

    # Create CDP session and listen to captcha events
    client = context.new_cdp_session(page)

    def handle_captcha_event(event):
        if event["name"] == "detected":
            print(f"{event['captchaType']} captcha detected on {event['url']}")
        
        if event["name"] == "solved":
            print(f"Captcha solved in {event['timeToSolve']}ms")
        
        if event["name"] == "failed":
            print(f"Captcha failed: {event['error']}")

    client.on("Captcha.lifecycle", handle_captcha_event)

    # Navigate to a page with captcha
    page.goto("https://example.com")

Event Types

Event Name	Description	Properties
`detected`	Fired when a captcha is detected on the page	`captchaType`, `url`
`solved`	Fired when the captcha is successfully solved	`timeToSolve` (in milliseconds)
`failed`	Fired when captcha solving fails	`error`

Session warm-up

Some sites show a login or sign-up wall to a browser they have never seen, even with stealth on: they check whether this browser has already run their own scripts once, on the IP it is using now. Turn on browser.warm_up and the session loads the site’s homepage once before it is handed to you, so your first navigation arrives with a jar those checks accept. On a warmed session, a direct navigation to that site also carries a search-engine referer; see Entering the site below. LinkedIn is the site covered today.

A warmed session needs both blockers off: browser.adblock.active: false and browser.popup_blocker.active: false. They stop the third-party analytics scripts these sites use to recognise a returning browser, so a warm-up under a blocker leaves no trace; the API rejects a warm_up request that leaves either one on.

const session = await Sessions.createSession({
    body: {
        browser: {
            warm_up: { active: true },
            adblock: { active: false },
            popup_blocker: { active: false },
            extra_stealth: { active: true }
        },
        session: {
            proxy: { active: true }
        }
    }
});

session = anchorClient.sessions.create_session(
    browser={
        "warm_up": {"active": True},
        "adblock": {"active": False},
        "popup_blocker": {"active": False},
        "extra_stealth": {"active": True}
    },
    session={
        "proxy": {"active": True}
    }
)

The warm-up runs before the create-session call returns and adds about ten seconds to session creation; that time counts toward the session’s duration. It loads the page in the session’s first tab, which is left blank afterwards.

Entering the site. Some sites, LinkedIn among them, show a public page to a visitor arriving from a search result and wall the same browser on a direct navigation. On a warmed session the browser handles this for you: a direct navigation to the warm-up’s site carries a search referer, whether it comes from page.goto(profileUrl), the agent, or a URL typed into the address bar in the live view. Landing still depends on the reputation of the exit IP the session was given, and a new session gets a new exit.

The warm-up also makes one request to ipinfo.io through the session’s exit to record which IP the session used; it counts as session traffic like the rest of the warm-up.

Introduction

Platform

Integrations

Account

What is Extra Stealth Mode?

Quick start - Enable stealth features

Using stealth with tasks

Usage with Profiles

Enabling Console Logs

Catching Captcha Events

Event Types

Session warm-up

​What is Extra Stealth Mode?

​Quick start - Enable stealth features

​Using stealth with tasks

​Usage with Profiles

​Enabling Console Logs

​Catching Captcha Events

​Event Types

​Session warm-up

What is Extra Stealth Mode?

Quick start - Enable stealth features

Using stealth with tasks

Usage with Profiles

Enabling Console Logs

Catching Captcha Events

Event Types

Session warm-up