Guide8 min read

Automated CAPTCHA Solving in Antidetect Browsers: A Practical Guide

A step-by-step look at how Ornold detects sitekeys, identifies challenge types, and injects tokens across many browser profiles at once.

Apr 5, 2026

Why CAPTCHAs Are Different in Antidetect Workflows

In a normal browser, you hit a CAPTCHA once and move on. In antidetect automation, CAPTCHAs appear across dozens of browser profiles simultaneously — each with its own session, cookies, and fingerprint. Solving them one by one defeats the purpose of parallel automation.

Ornold handles CAPTCHA solving as a batch operation: detect the challenge type across all active sessions, extract sitekeys, send them to a solver, and inject the response tokens — all in one coordinated pass.

Supported CAPTCHA Types

Ornold detects and solves the most common challenge types found on modern websites:

reCAPTCHA v2 — The classic "I'm not a robot" checkbox and image grid challenges
reCAPTCHA v3 — Invisible score-based verification that runs in the background
hCaptcha — Image classification challenges ("select all images with motorcycles")
Cloudflare Turnstile — The non-interactive challenge that replaced reCAPTCHA on many sites
Custom challenges — Press-and-hold buttons, slider puzzles, and other interactive verifications

The solver picks the right approach automatically based on what it detects on the page. You don't need to specify the CAPTCHA type — just call `browser_solve_captcha()` and Ornold figures out the rest.

How the Solving Pipeline Works

The CAPTCHA solving process has four stages. Each one runs across all active browser sessions in parallel.

Stage 1 — Detection

Ornold scans each active browser session for known CAPTCHA patterns. It checks for:

reCAPTCHA iframes and script tags (`google.com/recaptcha`)
hCaptcha containers and API scripts (`hcaptcha.com`)
Turnstile widgets (`challenges.cloudflare.com`)
Custom challenge elements (press-and-hold buttons, slider tracks)

Detection runs via DOM inspection and, when needed, visual analysis. If a CAPTCHA is hidden behind an overlay or loaded dynamically, the visual fallback catches it.

// Detection happens automatically when you call solve
const result = await browser_solve_captcha();
// result shows which sessions had CAPTCHAs and their types
// { total: 20, detected: 18, solved: 18, failed: 0 }

Stage 2 — Sitekey Extraction

Every CAPTCHA widget is tied to a sitekey — a public identifier that tells the CAPTCHA provider which site is requesting verification. Ornold extracts this key from the page DOM automatically.

For reCAPTCHA, the sitekey lives in the `data-sitekey` attribute of the widget div or in the script URL parameters. For hCaptcha, it's in a similar attribute. For Turnstile, it's embedded in the Cloudflare script configuration.

The sitekey, along with the page URL, gets sent to the solving service. This is what makes the solution valid — the token is generated for that specific site and key combination.

Stage 3 — Token Generation

Ornold sends the sitekey and page URL to a CAPTCHA solving service (2captcha). The service returns a response token — a string that proves the challenge was completed.

Solving times vary by CAPTCHA type:

reCAPTCHA v2 — 15-45 seconds (image recognition required)
reCAPTCHA v3 — 5-15 seconds (score-based, no images)
hCaptcha — 15-60 seconds (depends on difficulty tier)
Turnstile — 5-20 seconds (usually faster than image-based challenges)

Tokens are generated in parallel for all sessions. If 20 browsers need solving, all 20 requests go out simultaneously. Total wait time is roughly the same as solving one.

Stage 4 — Token Injection

Once the token arrives, Ornold injects it into the page. The injection method depends on the CAPTCHA type:

reCAPTCHA v2/v3 — Sets the `g-recaptcha-response` textarea value and calls the callback function
hCaptcha — Sets the `h-captcha-response` field and triggers the verification callback
Turnstile — Injects the token into the Turnstile response field and dispatches the success event

After injection, Ornold optionally clicks the submit button or waits for the page to auto-advance. The CAPTCHA widget disappears, and the form proceeds as if a human solved it.

// Full solve + verification flow
await browser_parallel_navigate({ url: "https://target.example/signup" });
await browser_parallel_fill({ ref: "email", values: emails });

// Solve CAPTCHAs across all sessions
const result = await browser_solve_captcha();
console.log(`Solved: ${result.solved}/${result.total}`);

// Submit the form
await browser_parallel_click({ ref: "submit" });

// Verify success
await browser_parallel_wait_for({ text: "Account created", timeoutMs: 15000 });

Handling Press-and-Hold Challenges

Some sites use custom challenges that require holding down a button for several seconds. These can't be solved with token injection — they need actual mouse interaction.

Ornold detects press-and-hold challenges visually and simulates the interaction: mouse down on the button, hold for the required duration, then release. This works across all active sessions in parallel.

// Press-and-hold detection and solving
const captchaCheck = await browser_detect_press_hold();
if (captchaCheck.detected) {
  await browser_solve_press_hold();
  // Waits for the hold duration, then releases
}

Batch CAPTCHA Solving in Practice

Here's what a real CAPTCHA solving run looks like across 30 Linken Sphere sessions during an account registration flow:

Navigate all 30 sessions to the signup page
Fill form fields with per-profile data (unique emails, names, etc.)
Call `browser_solve_captcha()` — Ornold detects reCAPTCHA v2 on 28 sessions, Turnstile on 2 sessions
All 30 solve requests go out in parallel
Tokens come back in 15-40 seconds
Ornold injects tokens and clicks submit on each session
29 of 30 succeed. 1 session gets a secondary challenge — Ornold retries automatically

Post-Solve Validation

Solving the CAPTCHA is only half the job. You need to verify that the solution was accepted and the page moved forward. Ornold provides tools for this:

// Verify all sessions advanced past the CAPTCHA
const status = await browser_status();
// Check which sessions are on the expected page
await browser_parallel_wait_for({ text: "Welcome", timeoutMs: 10000 });

// If some sessions are stuck, take a screenshot to diagnose
await browser_parallel_screenshot();

If a session fails validation, you can retry the solve for just that session, or flag it for manual review. The key is catching failures early instead of discovering them at the end of a long workflow.

CAPTCHA Credits and Billing

Each CAPTCHA solve consumes one credit from your Ornold account. Credits are deducted when the solving service returns a token — not when you call the solve function.

Free accounts get 5 CAPTCHA credits after completing the onboarding tour
Paid plans include a monthly credit allowance based on your tier
Additional credits can be purchased separately
Failed solves (where the service couldn't generate a token) don't consume credits

Check your credit balance on the Ornold dashboard before running large batches. Running out of credits mid-batch means some sessions will have unsolved CAPTCHAs.

Troubleshooting Common Issues

"CAPTCHA not detected" — The page may load the challenge dynamically. Add a wait before solving: `await browser_parallel_wait_for({ selector: "iframe[src*=recaptcha]", timeoutMs: 10000 })`
"Token rejected" — The token may have expired (they're valid for ~2 minutes). Make sure the form is ready before solving, so you can submit immediately after.
"Solve timeout" — The solving service is overloaded or the CAPTCHA type is unusually difficult. Retry once. If it persists, check the Ornold dashboard for service status.
"Partial batch failure" — Some sessions solved, others didn't. Use `browser_status()` to identify stuck sessions and retry only those.
"Press-and-hold not working" — Make sure the challenge element is visible and not covered by another overlay. Try scrolling to it first.

Best Practices

Fill the form before solving the CAPTCHA. Tokens expire in ~2 minutes, so minimize the time between solve and submit.
Use `browser_status()` after solving to verify all sessions advanced. Don't assume success.
For large batches (50+ sessions), solve in groups of 20-30 to avoid overwhelming the solving service.
Monitor your credit balance. Set up alerts on the dashboard if available.
If a site frequently changes CAPTCHA providers, use the auto-detect flow instead of hardcoding a type.

Explainer