---
site: steel.dev
collection: docs
canonical_url: https://steel.dev/docs/stealth/fingerprints
markdown_url: https://steel.dev/docs/stealth/fingerprints.md
content_signal: ai-input=yes, ai-train=yes, search=yes
title: Fingerprints
description: Each session gets a realistic browser fingerprint. Turn it off, make input human-like, or set your own user agent.
summary: Each session gets a realistic browser fingerprint.
type: how-to
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/stealth-browser.md
agent_setup: https://setup.steel.dev/install.md
docs_index: https://steel.dev/docs/sitemap.md
---

# Fingerprints

A browser fingerprint is the set of values that a site reads to tell one browser from another, such as the user agent, platform, fonts and media devices. Steel gives each session a realistic fingerprint, so that the browser looks like a common browser and not like automation. You do not need an option for it.

You can make the input human-like with `humanizeInteractions`, turn the fingerprint off with `skipFingerprintInjection`, or send your own `userAgent`. [How stealth works](https://steel.dev/docs/stealth) explains what sites check.

## Before you begin

Put your Steel API key in the `STEEL_API_KEY` environment variable. Then install the Steel SDK and Playwright.

**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.

## How fingerprints are set

When a session starts, Steel picks a desktop fingerprint and injects it into the browser. These settings change that choice:

- A session that starts from a [profile](https://steel.dev/docs/logins/profiles) uses the user agent that the profile saved, or the request's `userAgent` if it sets one. Steel injects no other fingerprint values into it.
- A session with `deviceConfig` set to `{ device: "mobile" }` gets a mobile fingerprint. See [Set the device and viewport](https://steel.dev/docs/sessions/devices).
- A session with a custom `userAgent` gets no fingerprint from Steel. See [Set a user agent](https://steel.dev/docs/stealth/fingerprints#set-a-user-agent).

This program creates a session and prints two of the values that a site reads.

**TypeScript**

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

const client = new Steel();
const session = await client.sessions.create();

try {
  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");
  const values = await page.evaluate(() =>
    JSON.stringify({ userAgent: navigator.userAgent, platform: navigator.platform }),
  );
  console.log(values);
  await browser.close();
} finally {
  await client.sessions.release(session.id);
}
```

**Python**

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

client = Steel()
session = client.sessions.create()

try:
    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")
        values = page.evaluate(
            "() => JSON.stringify({ userAgent: navigator.userAgent, platform: navigator.platform })"
        )
        print(values)
        browser.close()
finally:
    client.sessions.release(session.id)
```

Run the program:

**TypeScript**

```sh
npx tsx fingerprint.mts
```

**Python**

```sh
python fingerprint.py
```

The program prints both values. They can change from one session to the next.

```json nocopy
{"userAgent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/157.0.0.0 Safari/537.36","platform":"Linux x86_64"}
```

## Make input human-like

Set `humanizeInteractions` to `true` in `stealthConfig`. Steel then moves the mouse along a curved path to each point, and adds a random pause of 10 to 150 milliseconds before each key event. It does this only for the mouse and keyboard input that your code sends over CDP (Chrome DevTools Protocol), not for Commands, computer actions, the MCP server or the CLI. Use `humanizeInteractions` on sites that watch how the pointer moves and how fast text appears.

**TypeScript**

```ts
const session = await client.sessions.create({
  stealthConfig: { humanizeInteractions: true },
});
```

**Python**

```python
session = client.sessions.create(
    stealth_config={"humanize_interactions": True},
)
```

**Go**

```go
session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	StealthConfig: steel.F(steel.SessionNewParamsStealthConfig{
		HumanizeInteractions: steel.F(true),
	}),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        stealth_config: Some(steel_rs::SessionCreateParamsStealthConfig {
            humanize_interactions: Some(true),
            ..Default::default()
        }),
        ..Default::default()
    })
    .await?;
```

Your code does not change. Steel changes the `Input.dispatchMouseEvent` and `Input.dispatchKeyEvent` commands that reach the session, whichever library sends them.

## Skip fingerprint injection

Set `skipFingerprintInjection` to `true` in `stealthConfig`. Steel then does not generate a fingerprint for the session, and the browser shows its own values.

**TypeScript**

```ts
const session = await client.sessions.create({
  stealthConfig: { skipFingerprintInjection: true },
});
```

**Python**

```python
session = client.sessions.create(
    stealth_config={"skip_fingerprint_injection": True},
)
```

**Go**

```go
session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	StealthConfig: steel.F(steel.SessionNewParamsStealthConfig{
		SkipFingerprintInjection: steel.F(true),
	}),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        stealth_config: Some(steel_rs::SessionCreateParamsStealthConfig {
            skip_fingerprint_injection: Some(true),
            ..Default::default()
        }),
        ..Default::default()
    })
    .await?;
```

Use this option only when your code sets the fingerprint itself.

## Set a user agent

Set `userAgent` to the string that the browser sends. Use it when a site expects a certain user agent, or when a site allows your crawler by its name.

> **Warning**
>
> A custom user agent replaces the fingerprint. Steel does not pick a fingerprint for a session that has `userAgent`, so the browser's other values no longer match a common browser.

This program creates a session with a user agent and prints the user agent that a page sees.

**TypeScript**

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

const client = new Steel();
const session = await client.sessions.create({
  userAgent: "ExampleCrawler/1.0 (+https://example.com/crawler)",
});

try {
  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(await page.evaluate(() => navigator.userAgent));
  await browser.close();
} finally {
  await client.sessions.release(session.id);
}
```

**Python**

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

client = Steel()
session = client.sessions.create(
    user_agent="ExampleCrawler/1.0 (+https://example.com/crawler)",
)

try:
    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(page.evaluate("() => navigator.userAgent"))
        browser.close()
finally:
    client.sessions.release(session.id)
```

Run the program:

**TypeScript**

```sh
npx tsx user-agent.mts
```

**Python**

```sh
python user_agent.py
```

The program prints the user agent that you set.

```text nocopy
ExampleCrawler/1.0 (+https://example.com/crawler)
```

## Check that it worked

The values that the programs print show what a page reads, not whether a site accepts the session. To check that, run your task on the site several times with the same options. When the fingerprint and `humanizeInteractions` work, the sessions end without the signal `bot_detection_triggered`, as [Check the signals](https://steel.dev/docs/stealth/get-past-bot-detection#check-the-signals) shows.

## Next steps

- [Proxies](https://steel.dev/docs/stealth/proxies): Give the session a residential IP address.
- [CAPTCHA solving](https://steel.dev/docs/stealth/captcha-solving): Clear the challenges that a fingerprint does not prevent.
- [Get past bot detection](https://steel.dev/docs/stealth/get-past-bot-detection): Find out what a site reacts to when the fingerprint is not enough.
