You are running an automation flow and every few dozen requests the run stalls on a verification gate. Your retry logic repeats, and the job still misses its SLA.

Instead of rebuilding CAPTCHA tooling, do this: use Steel's CAPTCHA layer to prevent common challenges, solve when needed, and keep the session recoverable.

In the wild, this control loop commonly appears in:

• web scraping and browser automation jobs.

• login portals, account-creation flows, and payment checks.

• contact forms, polls, and dashboard actions protected by bot defenses.

What a CAPTCHA solver is

A CAPTCHA solver is a mechanism that observes the challenge lifecycle and returns the expected response token so an automated flow can move forward. In production, this usually means a mix of:

• machine learning inference

• third-party solving services

• browser-level automation

• token flow handling when a challenge provides one

The goal is reliability, not just convenience. If automation depends on a challenge-heavy surface, this layer matters.

CAPTCHAs can be active, where a visible challenge appears, or passive, where behavior-based checks trigger friction before a widget is shown. Legacy formats still include text, image, and audio CAPTCHAs, while modern systems use behavioral scoring from movement and timing signals.

What Steel says a CAPTCHA solver does

Steel uses a two-pronged model:

• Prevention first with realistic browser profiles that reduce challenge frequency.

• Automatic solving when a CAPTCHA still appears.

This matches the anti-bot defense model, where the protection stack often does much more than just showing a puzzle, including fingerprint, behavioral, and request signals before a challenge is even shown.

How Steel handles CAPTCHAs inside a session

The docs describe this internal flow:

1. detect CAPTCHA elements with page signal checks.

2. track CAPTCHA state by page.

3. classify the challenge type.

4. solve using an internal route.

5. verify success before continuing.

Even with this structure, challenge handling is not guaranteed. Plans include operational limits and latency impact.

Enable automatic solving in session creation

To enable autosolving, set solveCaptcha: true.

JavaScript (Node.js): Creating a Session with Captcha & Stealth Config

import Steel from 'steel-sdk';

const client = new Steel();

const session = await client.sessions.create({
  solveCaptcha: true
});

import Steel from 'steel-sdk';

const client = new Steel();

const session = await client.sessions.create({
  solveCaptcha: true
});

import Steel from 'steel-sdk';

const client = new Steel();

const session = await client.sessions.create({
  solveCaptcha: true
});

import Steel from 'steel-sdk';

const client = new Steel();

const session = await client.sessions.create({
  solveCaptcha: true
});

Python: Creating a Session with Captcha & Stealth Configuration

from steel import Steel

client = Steel()

session = client.sessions.create(
    solve_captcha=True
)

from steel import Steel

client = Steel()

session = client.sessions.create(
    solve_captcha=True
)

from steel import Steel

client = Steel()

session = client.sessions.create(
    solve_captcha=True
)

from steel import Steel

client = Steel()

session = client.sessions.create(
    solve_captcha=True
)

To keep detection but avoid automatic solves, disable autoCaptchaSolving in stealthConfig.

JavaScript (Node.js) – Async Session Creation with Captcha & Stealth Config

const session = await client.sessions.create({
  solveCaptcha: true,
  stealthConfig: {
    autoCaptchaSolving: false
  }
});

const session = await client.sessions.create({
  solveCaptcha: true,
  stealthConfig: {
    autoCaptchaSolving: false
  }
});

const session = await client.sessions.create({
  solveCaptcha: true,
  stealthConfig: {
    autoCaptchaSolving: false
  }
});

const session = await client.sessions.create({
  solveCaptcha: true,
  stealthConfig: {
    autoCaptchaSolving: false
  }
});

Python – Session Creation with Captcha & Stealth Configuration

session = client.sessions.create(
    solve_captcha=True,
    stealth_config={
        "autoCaptchaSolving": False
    }
)

session = client.sessions.create(
    solve_captcha=True,
    stealth_config={
        "autoCaptchaSolving": False
    }
)

session = client.sessions.create(
    solve_captcha=True,
    stealth_config={
        "autoCaptchaSolving": False
    }
)

session = client.sessions.create(
    solve_captcha=True,
    stealth_config={
        "autoCaptchaSolving": False
    }
)

Manual solve for fine control

If automation should only solve when explicit signals happen, you can call the solve endpoint directly. The same target can be selected by session-level auto-detection, task ID, URL, or page ID.

JavaScript (Node.js) – Solving Captchas with Optional Parameters

await client.sessions.captchas.solve('sessionId');
await client.sessions.captchas.solve('sessionId', { taskId: 'task_123' });
await client.sessions.captchas.solve('sessionId', { url: 'https://example.com' });
await client.sessions.captchas.solve('sessionId', { pageId: 'page_123' });

await client.sessions.captchas.solve('sessionId');
await client.sessions.captchas.solve('sessionId', { taskId: 'task_123' });
await client.sessions.captchas.solve('sessionId', { url: 'https://example.com' });
await client.sessions.captchas.solve('sessionId', { pageId: 'page_123' });

await client.sessions.captchas.solve('sessionId');
await client.sessions.captchas.solve('sessionId', { taskId: 'task_123' });
await client.sessions.captchas.solve('sessionId', { url: 'https://example.com' });
await client.sessions.captchas.solve('sessionId', { pageId: 'page_123' });

await client.sessions.captchas.solve('sessionId');
await client.sessions.captchas.solve('sessionId', { taskId: 'task_123' });
await client.sessions.captchas.solve('sessionId', { url: 'https://example.com' });
await client.sessions.captchas.solve('sessionId', { pageId: 'page_123' });

Python – Solving Captchas with Optional Arguments

client.sessions.captchas.solve("sessionId")
client.sessions.captchas.solve("sessionId", task_id="task_123")
client.sessions.captchas.solve("sessionId", url="https://example.com")
client.sessions.captchas.solve("sessionId", page_id="page_123")

client.sessions.captchas.solve("sessionId")
client.sessions.captchas.solve("sessionId", task_id="task_123")
client.sessions.captchas.solve("sessionId", url="https://example.com")
client.sessions.captchas.solve("sessionId", page_id="page_123")

client.sessions.captchas.solve("sessionId")
client.sessions.captchas.solve("sessionId", task_id="task_123")
client.sessions.captchas.solve("sessionId", url="https://example.com")
client.sessions.captchas.solve("sessionId", page_id="page_123")

client.sessions.captchas.solve("sessionId")
client.sessions.captchas.solve("sessionId", task_id="task_123")
client.sessions.captchas.solve("sessionId", url="https://example.com")
client.sessions.captchas.solve("sessionId", page_id="page_123")

The identifiers used in manual mode come from the CAPTCHA status response.

Works for x, not yet for y

Works for:

• session automation with supported service types.

• teams that can budget extra timeout and retry logic around protected pages.

• Developer, Startup, and Enterprise plan users.

Not yet for:

• guaranteed 100% success.

• flows where policy explicitly bans automation or forbids any CAPTCHA solving.

• unsupported challenge systems such as enterprise-specific and specialized CAPTCHAs.

• free tier use, since solving is plan-gated.

What to use with it

A practical setup still needs human review and controls around waits, retries, permissions, and request rhythm, plus verification and recovery checkpoints. This is a production reliability pattern, not a magic switch. Use this to reduce friction in real automations, not to bypass the intent of a security control. In sensitive environments, pair solving with manual approvals and policy checks so the execution stays auditable and compliant. This is the same control mindset used in production agents, where reliability is managed with explicit guardrails and recovery loops.

When you want the current official behavior and edge-case notes read our docs: CAPTCHA Solving Docs.

Humans use Chrome. Agents use Steel.