Stealth Browser Runtime: Hosted Chromium for AI Agents

# Stealth Browser Runtime: Hosted Chromium for AI Agents

A stealth browser is not about hiding from the law. It is about running automated browser sessions that do not get flagged, blocked, or rate-limited by the websites your AI agents depend on. When you run browser-use workflows locally, your requests come from a residential IP with a standard Chrome fingerprint—and that is exactly what anti-bot systems are trained to detect and block.

Remote Browser provides a stealth browser runtime built on hosted Chromium. It gives AI agents a dedicated browser session with configurable browser settings, persistent profiles, and clean network egress. This post explains what a stealth browser actually does, why hosted Chromium beats local setups for production workloads, and how to integrate it with your existing browser-use stack.

What Is a Stealth Browser?

A stealth browser is a browser instance configured to avoid detection by anti-bot systems. Detection happens at multiple layers:

• TLS fingerprinting: The way your browser negotiates TLS connections reveals the browser engine and version.
• HTTP headers: Order, casing, and values of headers like User-Agent, Accept, and Sec-CH-UA are unique per browser.
• JavaScript canvas and WebGL fingerprints: These expose GPU, rendering, and OS details.
• IP reputation: Datacenter IPs are flagged; residential IPs are trusted more.
• Behavioral signals: Mouse movement, scroll patterns, and timing between actions.

A stealth browser addresses these layers. It uses a real Chromium engine, not a headless fork with detectable quirks. It sends consistent headers. It can route traffic through proxies. And it isolates sessions so that one agent's cookies or storage do not leak into another.

The term "stealth" is often associated with scraping or ad verification, but the same technology applies to AI agents. If your agent needs to log into a SaaS dashboard, fetch data from a protected API, or interact with a site that uses Cloudflare, a stealth browser runtime improves success rates.

Why Hosted Chromium Beats Local Setup

Running a stealth browser locally works for a single script. It breaks at scale. Here is why:

Local Chromium is fine for development. For production, you need a runtime that handles the operational overhead.

The Remote Browser Stealth Runtime

Remote Browser is a browser API that provides hosted Chromium sessions for AI agents. It is compatible with Playwright, Puppeteer, and Selenium, and it exposes the Chrome DevTools Protocol (CDP) directly. This means you can keep your existing browser-use code and swap the browser launch call for a remote session.

Key features relevant to stealth browser use cases:

• Configurable browser settings: Set user agents, viewport sizes, locale, and timezone per session. These settings align your browser fingerprint with the target site's expectations.
• Persistent profiles: Store cookies, localStorage, and session data across runs. Log in once, reuse the session for hours or days.
• Proxy support: Route traffic through residential or datacenter proxies. This decouples your browser fingerprint from your IP reputation.
• Session isolation: Each browser session runs in its own container. No cross-contamination between agents.
• Live viewer: Watch the browser in real time. Useful for debugging stealth issues or verifying that a page rendered correctly.
• CDP access: Use raw CDP commands for advanced control—network interception, request modification, or JavaScript evaluation.

How to Use a Stealth Browser with Playwright

The integration is straightforward. Instead of launching a local Chromium instance, you connect to a remote browser session via CDP.

Here is a TypeScript example using Playwright:

import { chromium } from 'playwright';
import { RemoteBrowser } from '@remote-browser/sdk';

async function runStealthAgent() {
  // Create a remote browser session
  const session = await RemoteBrowser.createSession({
    profile: 'my-agent-profile',      // persistent profile
    browserSettings: {
      userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
      viewport: { width: 1920, height: 1080 },
      locale: 'en-US',
      timezone: 'America/New_York',
    },
    proxy: {
      // Optional: route through a residential proxy
      // url: 'http://user:pass@proxy.example.com:8080'
    },
  });

  // Connect Playwright to the remote session via CDP
  const browser = await chromium.connectOverCDP(session.cdpEndpoint);
  const page = await browser.newPage();

  // Run your browser-use workflow
  await page.goto('https://example.com/login');
  await page.fill('#username', 'agent-user');
  await page.fill('#password', 'agent-pass');
  await page.click('#submit');

  // Wait for the dashboard to load
  await page.waitForSelector('.dashboard');

  // Extract data or perform actions
  const data = await page.evaluate(() => {
    return document.querySelector('.dashboard').textContent;
  });

  console.log('Extracted data:', data);

  // Clean up
  await browser.close();
  await session.terminate();
}

runStealthAgent().catch(console.error);

The cdpEndpoint is a WebSocket URL that Playwright connects to. The session runs on Remote Browser's infrastructure, so your local machine only sends commands and receives responses.

Stealth Browser Settings That Matter

Not all browser settings are equal. Here are the ones that have the most impact on detection rates:

User Agent

The user agent string must match the browser engine. If you send a Chrome user agent but the TLS fingerprint says Firefox, you will be flagged. Remote Browser uses real Chromium, so the user agent is consistent by default. Override it only when you need to match a specific Chrome version.

Viewport and Screen Properties

Headless browsers often report a viewport of 800x600 or a screen resolution of 0x0. Real users have varied viewports. Set a realistic viewport and match the screen.width and screen.height values.

Locale and Timezone

A browser with en-US locale but a timezone of Asia/Tokyo is suspicious. Set both to match the target audience. Remote Browser applies these settings at the Chromium level, so they are consistent across all JavaScript APIs.

WebGL and Canvas

These are harder to configure manually. Remote Browser runs full Chromium, not a stripped-down headless variant, so WebGL and Canvas rendering behave like a real browser. This is a significant advantage over puppeteer-extra-plugin-stealth, which patches JavaScript APIs but cannot change the underlying rendering engine.

IP Address

The IP address is the first thing anti-bot systems check. Datacenter IPs are flagged immediately. Residential IPs are trusted more. Remote Browser supports proxy configuration per session, so you can route traffic through the right egress point for your use case.

Stealth Browser vs. Browser-Use Open Source

The browser-use open-source library is popular for AI web agents. It provides a Python framework for controlling a browser with natural language instructions. However, it runs on local Chromium by default. That works for prototyping but fails in production for three reasons:

1. Detection: Local Chromium has a standard fingerprint. Anti-bot systems flag it quickly.
2. Scalability: Running multiple agents locally requires significant resources.
3. Reliability: Local browsers crash, lose sessions, and get blocked by rate limits.

Remote Browser is compatible with browser-use. You can point the library at a remote browser session instead of a local one. This gives you the stealth browser benefits without rewriting your agent logic.

For a deeper comparison, see our post on browser-use alternatives and why hosted Chromium wins for production workloads.

Use Cases for a Stealth Browser Runtime

AI Agents That Log In

If your agent needs to access a SaaS product, a stealth browser with persistent profiles is essential. The agent logs in once, the session is saved, and subsequent runs reuse the authenticated state. No repeated CAPTCHAs, no login failures.

Data Collection at Scale

Collecting public data from websites that use anti-bot protections requires a stealth browser. Rotating IPs and consistent fingerprints reduce the chance of being blocked. Remote Browser's session isolation ensures that one agent's actions do not affect another.

QA and Testing

Testing a web application from different geographic locations or with different browser profiles is a stealth browser use case. You can simulate a user in London with a Chrome browser, then a user in Sydney with the same browser. The live viewer lets you watch the test in real time.

Browser-Use Workflows

The browser-use library is designed for AI agents that interact with the web. Running it on a stealth browser runtime makes the agent more reliable. The agent can complete tasks that would otherwise fail due to bot detection.

Pricing and Limits

Remote Browser offers a browser-hour model. Browsers are metered by the hour, and you pay only for what you use. There is no subscription required for basic usage. For current pricing and session limits, check the pricing page.

The cost is predictable: create a session, run your agent, terminate the session. Persistent profiles and proxy configuration are available on all plans, but specific limits vary. Refer to the pricing page for details.

Getting Started

To start using a stealth browser runtime:

1. Create an account on remote-browser.dev.
2. Get an API key from the dashboard.
3. Install the SDK or use the REST API directly.
4. Create a session with your desired browser settings.
5. Connect via CDP or Playwright/Puppeteer.

The documentation covers the full API, including session management, profile persistence, and proxy configuration.

Conclusion

A stealth browser is a practical requirement for AI agents that interact with the modern web. Local Chromium gets blocked. Hosted Chromium with configurable settings, persistent profiles, and clean IP egress does not.

Remote Browser provides that runtime. It is compatible with your existing browser-use code, scales horizontally, and gives you the debugging tools you need when things go wrong.

If you are building an AI agent that needs reliable web access, try a stealth browser runtime. Start with a free session and see the difference.

For more context on why remote browsers matter for AI agents, read our post on remote browsers for AI agents or the practical guide to remote web browsers.