---
site: steel.dev
collection: docs
canonical_url: https://steel.dev/docs/stealth/stealth-browser
markdown_url: https://steel.dev/docs/stealth/stealth-browser.md
content_signal: ai-input=yes, ai-train=yes, search=yes
title: Stealth Browser
description: Run a session on Stealth Browser, Steel's own Chromium fork, when a site still blocks the default browser.
summary: Run a session on Stealth Browser, Steel's own Chromium fork, when a site still blocks the default browser.
type: how-to
plans:
  - enterprise
reviewed: 2026-11-12
prerequisites:
  - https://steel.dev/docs/stealth.md
related:
  - https://steel.dev/docs/stealth/get-past-bot-detection.md
  - https://steel.dev/docs/stealth/proxies.md
  - https://steel.dev/docs/stealth/dedicated-ips.md
  - https://steel.dev/docs/stealth/captcha-solving.md
  - https://steel.dev/docs/stealth/fingerprints.md
agent_setup: https://setup.steel.dev/install.md
docs_index: https://steel.dev/docs/sitemap.md
---

# Stealth Browser

Stealth Browser is Steel's own Chromium fork, for sites with strict bot detection. A session runs on Chrome by default, and Steel injects a fingerprint into it. Stealth Browser sets its fingerprint inside the browser itself. Use it when a site still blocks a session that has a proxy, CAPTCHA solving and Steel's fingerprint. [What each plan includes](https://steel.dev/docs/platform/pricing#what-each-plan-includes) shows which plans have it.

Stealth Browser changes the browser, not the network. It does not change the session's IP address, so use it with a [proxy](https://steel.dev/docs/stealth/proxies) when the site checks the address. [Get past bot detection](https://steel.dev/docs/stealth/get-past-bot-detection) helps you choose the setup that a site needs.

## Get access

Stealth Browser is off until Steel turns it on for your organization. Then any session that your organization creates can ask for it.

- On Enterprise, ask your account team or [Support](https://steel.dev/docs/support) to turn it on.
- On another plan, [contact sales](https://steel.dev/enterprise). Steel can also turn it on for a trial that ends on a set date. When the trial ends, a request for Stealth Browser fails.

To check your access, create a session with Stealth Browser, as in [Run a session on Stealth Browser](https://steel.dev/docs/stealth/stealth-browser#run-a-session-on-stealth-browser). Without access, the request fails with a `403`, as [Troubleshooting](https://steel.dev/docs/stealth/stealth-browser#troubleshooting) shows.

## Before you begin

Put your Steel API key in the `STEEL_API_KEY` environment variable. Then install the Steel SDK and Playwright. You do not need `playwright install`, because the browser runs in Steel.

**TypeScript**

```sh
npm install steel-sdk playwright
```

**Python**

```sh
python3 -m venv .venv
source .venv/bin/activate
pip install steel-sdk playwright
```

In Go and Rust, install only the SDK, as the [Go](https://steel.dev/docs/reference/sdks/go#install) and [Rust](https://steel.dev/docs/reference/sdks/rust#install) SDK pages show. The code that drives the browser uses Playwright, so it is in TypeScript and Python only.

## Run a session on Stealth Browser

Add `useStealthBrowser` to `experimentalFeatures` when you create the session. The rest of your code does not change. You connect to the session and release it as you do with any session.

**TypeScript**

```ts
const session = await client.sessions.create({
  experimentalFeatures: ["useStealthBrowser"],
});
```

**Python**

```python
session = client.sessions.create(
    experimental_features=["useStealthBrowser"],
)
```

**Go**

```go
session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	ExperimentalFeatures: steel.F([]string{"useStealthBrowser"}),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        experimental_features: Some(vec!["useStealthBrowser".to_owned()]),
        ..Default::default()
    })
    .await?;
```

This program creates a session on Stealth Browser, prints its browser mode, opens a page, prints the page's title, and releases the session.

**TypeScript**

```ts file=stealth-browser.mts
import Steel from "steel-sdk";
import { chromium } from "playwright";

const client = new Steel();
const session = await client.sessions.create({
  experimentalFeatures: ["useStealthBrowser"],
});

try {
  console.log(`Browser mode: ${session.browserMode}`);
  const browser = await chromium.connectOverCDP(session.websocketUrl);
  const context = browser.contexts()[0];
  const page = context.pages()[0] ?? (await context.newPage());
  await page.goto("https://example.com");
  console.log(`Title: ${await page.title()}`);
  await browser.close();
} finally {
  await client.sessions.release(session.id);
}
```

**Python**

```python file=stealth_browser.py
from playwright.sync_api import sync_playwright
from steel import Steel

client = Steel()
session = client.sessions.create(experimental_features=["useStealthBrowser"])

try:
    print(f"Browser mode: {session.browser_mode}")
    with sync_playwright() as playwright:
        browser = playwright.chromium.connect_over_cdp(session.websocket_url)
        context = browser.contexts[0]
        page = context.pages[0] if context.pages else context.new_page()
        page.goto("https://example.com")
        print(f"Title: {page.title()}")
        browser.close()
finally:
    client.sessions.release(session.id)
```

Run the program:

**TypeScript**

```sh
npx tsx stealth-browser.mts
```

**Python**

```sh
python stealth_browser.py
```

The program prints the browser mode `stealth` and the page's title.

```text nocopy
Browser mode: stealth
Title: Example Domain
```

## Check that a session runs on Stealth Browser

A session has a `browserMode` field. It is `stealth` for a session on Stealth Browser, and `standard` for a session on the default browser. The session that `sessions.create` returns has it, and so does a session that you get later by its ID.

**TypeScript**

```ts
const session = await client.sessions.retrieve(sessionId);
console.log(session.browserMode);
```

**Python**

```python
session = client.sessions.retrieve(session_id)
print(session.browser_mode)
```

**Go**

```go
session, err := client.Sessions.Get(ctx, sessionID)
if err != nil {
	return err
}
fmt.Println(session.BrowserMode)
```

**Rust**

```rust
let session = client.sessions().retrieve(&session_id).await?;
println!("{:?}", session.browser_mode);
```

For a session on Stealth Browser, the code prints `stealth` (`Stealth` in Rust).

```text nocopy
stealth
```

The browser mode tells you which browser ran. It does not tell you whether a site blocked the session. For that, read the session's [signals](https://steel.dev/docs/observability/signals) after it ends, as in [Check the signals](https://steel.dev/docs/stealth/get-past-bot-detection#check-the-signals).

## Use Stealth Browser with a proxy and CAPTCHA solving

Stealth Browser works with the other stealth options. This call adds a Steel proxy and CAPTCHA solving:

**TypeScript**

```ts
const session = await client.sessions.create({
  experimentalFeatures: ["useStealthBrowser"],
  useProxy: true,
  solveCaptcha: true,
});
```

**Python**

```python
session = client.sessions.create(
    experimental_features=["useStealthBrowser"],
    use_proxy=True,
    solve_captcha=True,
)
```

**Go**

```go
session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	ExperimentalFeatures: steel.F([]string{"useStealthBrowser"}),
	UseProxy:             steel.F[any](true),
	SolveCaptcha:         steel.F(true),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        experimental_features: Some(vec!["useStealthBrowser".to_owned()]),
        use_proxy: Some(serde_json::Value::Bool(true)),
        solve_captcha: Some(true),
        ..Default::default()
    })
    .await?;
```

In Rust, this code needs `cargo add serde_json`.

On Stealth Browser, CAPTCHA solving does not detect or solve Cloudflare Turnstile or reCAPTCHA v3. Stealth Browser is built to pass these two without a solver. They do not appear in the [CAPTCHA status](https://steel.dev/docs/stealth/captcha-solving#check-the-status), and they do not add `captcha_encountered` to the session's signals. When a Turnstile checkbox stays unchecked on the page for 3 seconds, Steel clicks it as a person would, and Cloudflare decides whether to let the session through. CAPTCHA solving still detects and solves the other types, such as reCAPTCHA v2 and hCaptcha.

`stealthConfig.humanizeInteractions` works on Stealth Browser as on the default browser. See [Make input human-like](https://steel.dev/docs/stealth/fingerprints#make-input-human-like).

## How Stealth Browser differs from the default browser

| | Default browser | Stealth Browser |
| - | - | - |
| Browser | Chrome | Steel's own Chromium fork |
| Fingerprint | Steel injects one into the browser. On a desktop session, it reports a Linux computer. | The browser applies its own. It can report a Windows computer. |
| `skipFingerprintInjection` in `stealthConfig` | Turns off Steel's fingerprint | Has no effect |
| Cloudflare Turnstile and reCAPTCHA v3, with `solveCaptcha` | Steel detects and solves them | Steel does not detect or solve them |
| `browserMode` | `standard` | `stealth` |
| Plans | Every plan | Enterprise |

A session on Stealth Browser can take longer to start than a session on the default browser.

## Plans and pricing

Steel bills a session on Stealth Browser as any other session: browser hours, plus proxy bandwidth and CAPTCHA solves when the session uses them. [What each plan includes](https://steel.dev/docs/platform/pricing#what-each-plan-includes) shows which plans have it.

## Troubleshooting

### The useStealthBrowser experimental feature is not enabled

```json nocopy
{
  "message": "The useStealthBrowser experimental feature is not enabled for this organization.",
  "error": "Forbidden",
  "linkToDocs": "https://docs.steel.dev/overview/sessions-api/session-lifecycle"
}
```

**Cause:** The request asks for Stealth Browser, but your organization has no access to it. Its plan does not include Stealth Browser, Steel has not turned on early access for it, and it has no trial, or its trial ended. The status is `403`, and the response has no `code`.

**Fix:** Ask for access, as [Get access](https://steel.dev/docs/stealth/stealth-browser#get-access) explains. To continue on the default browser, remove `useStealthBrowser` from `experimentalFeatures`.

**Verify:** Create the session again. The response has a session `id`, and its `browserMode` is `stealth`.

### `core_browser_locked`

```json nocopy
{
  "error": "Forbidden",
  "code": "core_browser_locked",
  "message": "Core Browser ('useStealthBrowser' in 'experimentalFeatures') is not available on your plan. Remove it from 'experimentalFeatures', or upgrade your plan.",
  "param": "experimentalFeatures",
  "retryable": false,
  "linkToDocs": "https://docs.steel.dev/overview/pricinglimits"
}
```

**Cause:** Steel turned on early access to Stealth Browser for your organization, but its plan does not include Stealth Browser, and it has no trial. Steel's billing check then refuses the session with `403` and the code `core_browser_locked`. The message calls Stealth Browser "Core Browser".

**Fix:** Ask Steel to add Stealth Browser to your plan, as [Get access](https://steel.dev/docs/stealth/stealth-browser#get-access) explains. To continue on the default browser, remove `useStealthBrowser` from `experimentalFeatures`.

**Verify:** Create the session again. The response has a session `id`, and its `browserMode` is `stealth`.

## Next steps

- [Get past bot detection](https://steel.dev/docs/stealth/get-past-bot-detection): Choose the setup that a site needs, and check that it worked.
- [Proxies](https://steel.dev/docs/stealth/proxies): Give a Stealth Browser session a residential address.
- [CAPTCHA solving](https://steel.dev/docs/stealth/captcha-solving): Solve the challenges that Stealth Browser does not pass by itself.
