What Is a CAPTCHA Solver? Automatic CAPTCHA Solving API

What Is a CAPTCHA Solver?

A CAPTCHA solver is a service that notices a CAPTCHA challenge on a page, produces a valid answer for it, and submits that answer back to the page so an automated session can continue. In Steel the solver runs inside the browser session, so you turn it on with a single session flag instead of wiring up a separate solving provider.

1
import Steel from 'steel-sdk';
2

3
const client = new Steel();
4

5
// One flag covers detection, solving, and verification for the whole session
6
const session = await client.sessions.create({
7
  solveCaptcha: true
8
});

Any solver, Steel's included, has to do three separate jobs, and a failure in any one of them looks the same from your automation's point of view:

• Detect the challenge, including invisible ones that never render a visible widget

• Solve it, using models, third-party solving services, or by reproducing the interaction a person would perform

• Submit and verify the resulting token or input so the target page actually accepts it

How Automated CAPTCHA Solving Works

When CAPTCHA solving is enabled on a session, every page runs through the same pipeline and each stage is reported as a task status you can read from the API:

1. 1

   Detection: The system continuously monitors the page for CAPTCHA elements using multiple detection methods:

   • DOM structure analysis

   • Known CAPTCHA iframe patterns

   • Common CAPTCHA API endpoints

   • Visual element detection

2. 2

   State Management: CAPTCHA states are tracked per page with real-time updates

3. 3

   Classification: Once detected, the system identifies the specific type of CAPTCHA and routes it to the appropriate solver.

4. 4

   Solving: CAPTCHAs are then solved by us using various methods:

   • Machine learning models

   • Third-party solving services

   • Browser automation techniques

   • Token manipulation (when applicable)

5. 5

   Verification: The system verifies that the CAPTCHA was successfully solved before allowing the session to continue.

1
const pages = await client.sessions.captchas.status(session.id);
2

3
for (const state of pages) {
4
  for (const task of state.tasks as Array<{ type: string; status: string }>) {
5
    // detected -> solving -> validating -> solved
6
    console.log(task.type, task.status);
7
  }
8
}

CAPTCHA Types Steel Detects and Solves

Each detected challenge is classified, and its type string is what you see on the task in the CAPTCHA status response. The types below cover what you will run into most often, and other widely used challenge types are auto-solved as well:

Read the types off the status response when you want to branch on what the page threw at you:

1
const pages = await client.sessions.captchas.status(session.id);
2
const tasks = pages.flatMap((state) => state.tasks as Array<{ type: string }>);
3

4
// e.g. ['turnstile', 'image_to_text']
5
console.log(tasks.map((task) => task.type));

How Steel Handles CAPTCHAs

Steel takes a two-pronged approach to dealing with CAPTCHAs:

1. 1

   Prevention First: Our sophisticated browser fingerprinting and anti-detection systems often prevent CAPTCHAs from appearing in the first place. We maintain realistic browser profiles that make your automated sessions appear more human-like, reducing the likelihood of triggering CAPTCHA challenges.

2. 2

   Automatic Solving: When CAPTCHAs do appear, our automatic solving system kicks in to handle them transparently, allowing your automation to continue without interruption.

Fingerprinting is applied to every session, so the practical decision is whether to pair it with residential IPs and solving on the sites that challenge you most:

1
const session = await client.sessions.create({
2
  useProxy: true,      // residential IP, fewer challenges triggered
3
  solveCaptcha: true   // fallback for the ones that still appear
4
});

Automatic vs Manual Solving

Automatic solving fires as soon as a challenge is detected and needs no further calls from you. Manual solving keeps detection on but waits for you to trigger the solve, which is useful when you want to decide whether a given challenge is worth solving at all.

Session Configuration

To enable autosolving, simply set solveCaptcha: true when creating a session.

1
import Steel from 'steel-sdk';
2

3
const client = new Steel();
4

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

To detect CAPTCHAs without automatically solving them, disable autoCaptchaSolving in the stealth config:

1
const session = await client.sessions.create({
2
  solveCaptcha: true,
3
  stealthConfig: {
4
    autoCaptchaSolving: false
5
  }
6
});

Manual Solving

If auto-solving is disabled, use the solve endpoint to trigger solving. You can solve all detected CAPTCHAs, or target a specific one with a value read from the CAPTCHA status response:

• taskId: the value of the task's id field

• url: the URL the challenge was detected on

• pageId: the page the challenge belongs to

1
// Solve all detected CAPTCHAs
2
await client.sessions.captchas.solve('sessionId');
3

4
// Solve specific task
5
await client.sessions.captchas.solve('sessionId', { taskId: 'task_123' });
6

7
// Solve by URL
8
await client.sessions.captchas.solve('sessionId', { url: 'https://example.com' });
9

10
// Solve by Page ID
11
await client.sessions.captchas.solve('sessionId', { pageId: 'page_123' });

Response Times

Solving adds wall-clock time to a run, and how much depends on the challenge type and the target site, so Steel does not quote a fixed figure. Every task carries its own timings instead, which means you can measure the real numbers for the sites you actually automate:

1
type CaptchaTiming = { type: string; status: string; totalDuration?: number };
2

3
const pages = await client.sessions.captchas.status(session.id);
4

5
for (const state of pages) {
6
  for (const task of state.tasks as CaptchaTiming[]) {
7
    // Milliseconds from detection to solved or failed
8
    console.log(task.type, task.status, task.totalDuration);
9
  }
10
}

Three fields on each task give you the full picture:

• detectionTime: when the challenge was spotted on the page

• solveTime: when solving finished

• totalDuration: milliseconds from detection to the terminal status

Best Practices for Implementation

1. Implement Proper Waiting

When navigating to pages that might contain CAPTCHAs, it's important to implement proper waiting strategies:

1
// Typescript example using Puppeteer
2
await page.waitForNetworkIdle();  // Wait for network activity to settle
3
await page.waitForTimeout(2000);  // Additional safety buffer

2. Detecting CAPTCHA Presence

You can detect CAPTCHA presence using these selectors:

1
// Common CAPTCHA selectors
2
const captchaSelectors = [
3
    'iframe[src*="recaptcha"]',
4
    '#captcha-box',
5
    '[class*="captcha"]'
6
];

Important Considerations

1. 1

   Plan Availability: CAPTCHA solving is only available on Developer, Startup, and Enterprise plans. It is not included in the free tier.

2. 2

   Success Rates: While our system has high success rates, CAPTCHA solving is not guaranteed to work 100% of the time. Always implement proper error handling.

3. 3

   Timing: CAPTCHA solving can add latency to your automation. Account for this in your timeouts and waiting strategies.

4. 4

   Rate Limits: Even with successful CAPTCHA solving, respect the target site's rate limits and terms of service.

Common Issues and Solutions

1. 1

   Timeout Issues

   • Increase your session timeout when working with CAPTCHA-heavy sites

   • Implement exponential backoff for retries

2. 2

   Detection Issues

   • Use Steel's built-in stealth profiles

   • Implement natural delays between actions

   • Rotate IP addresses using Steel's proxy features

3. 3

   Solving Failures

   • Implement proper error handling

   • Have fallback strategies ready

   • Consider implementing manual solving as a last resort

Best Practices for Avoiding CAPTCHAs

1. 1

   Use Steel's Fingerprinting: Our automatic fingerprinting often helps bypass avoidable CAPTCHAs entirely by making your sessions appear more human-like.

2. 2

   Session Management:

   • Reuse successful sessions when possible

   • Maintain cookies and session data

   • Use Steel's session persistence features

3. 3

   Request Patterns:

   • Implement natural delays between actions

   • Vary your request patterns

   • Avoid rapid, repetitive actions

Looking Forward

Steel is continuously improving its CAPTCHA handling capabilities. We regularly update our solving mechanisms to handle new CAPTCHA variants and improve success rates for existing ones, so check back here for the latest information about supported CAPTCHA types and best practices.

FAQ