TL;DR A CAPTCHA solver is a service that automatically completes a CAPTCHA challenge so an automated browser session can continue instead of stalling on it. Solvers work either by recognizing the challenge with a model or by handing it to a human worker, then returning the answer to the browser. For AI agents running real workflows, the more durable answer is not to solve every challenge but to have the agent show up with verified identity so fewer challenges appear at all.

If you have ever pointed an automated browser at a real website, you have hit a CAPTCHA. The page freezes on a checkbox or a grid of images, your script has no way to click through it, and the run dies. A CAPTCHA solver is the piece that gets you past that wall automatically.

What is a CAPTCHA solver?

A CAPTCHA solver is a service or tool that detects a CAPTCHA challenge on a page, produces the correct answer, and submits it so the browser can proceed without a person intervening. CAPTCHA stands for Completely Automated Public Turing test to tell Computers and Humans Apart: a test a site shows when it wants to confirm a real human is present. A solver's job is to complete that test on behalf of an automated session.

Solvers matter because CAPTCHAs are everywhere an automated browser wants to go: sign-up flows, checkout pages, search forms, and account logins. Without a way to handle them, any automation that touches those pages stops the moment a challenge appears.

How does a CAPTCHA solver work?

A CAPTCHA solver runs in three steps: it detects the challenge, computes the answer, and submits it back into the page. The difference between solvers is in the middle step, how they produce the answer.

• Model-based solving. A machine learning model reads the challenge and predicts the answer, for example transcribing distorted text, classifying images, or transcribing an audio challenge. This is fast and scales, but only as far as the model generalizes to new challenge types.
• Human-in-the-loop solving. The challenge is sent to a pool of human workers who solve it and return the answer through an API. This handles challenges a model cannot, at the cost of added latency and per-solve pricing.
• Token-based solving. For challenges that issue a verification token, the solver produces a valid token that the page accepts, rather than clicking through the visible widget.

In an automated browser, solving usually happens in the background. The session detects the challenge, runs the solve, and emits events so your code knows when solving starts and finishes. On Browserbase, CAPTCHA solving is on by default for every session, and the browser emits console events you can listen for so your agent waits instead of racing ahead:

const recaptcha = await page.goto("https://www.google.com/recaptcha/api2/demo");

page.on("console", (msg) => {
  if (msg.text() == "browserbase-solving-started") {
    console.log("Captcha Solving In Progress");
  } else if (msg.text() == "browserbase-solving-finished") {
    console.log("Captcha Solving Completed");
  }
});

Solving typically takes between 5 and 30 seconds depending on the challenge type, so listening for these events keeps your automation from acting on a page that is still locked. You can turn solving off per session by setting solveCaptchas to false when you create the session:

import Browserbase from "@browserbasehq/sdk";

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY! });

const session = await bb.sessions.create({
  browserSettings: {
    solveCaptchas: false,
  },
});

What types of CAPTCHAs do solvers handle?

Solvers are usually built around the challenge families that sites deploy most often. The tests have evolved from simple distorted text into scored, largely invisible checks, and solvers track that evolution.

Why do agents keep hitting CAPTCHAs?

Agents hit CAPTCHAs because sites can't tell a legitimate automated workflow from an abusive one, so they challenge anything that looks automated. The signals that trigger a challenge are rarely about the CAPTCHA itself: a data-center IP address, a shared or low-reputation network, a browser fingerprint that looks synthetic, or request timing that reads as machine-driven.

This is why a solver alone is a treadmill. You can complete every challenge a site throws, and the site will keep throwing them, because nothing about the underlying session has changed. The more effective move is to reduce how often challenges appear in the first place by improving the signals the request sends, and, increasingly, by letting the agent present a verifiable identity.

CAPTCHA solving vs verified access

Solving a CAPTCHA reacts to a challenge after it appears. Verified access works the other way around: the agent presents a verifiable identity up front, so trusted sites can grant access without a challenge at all. The two are complementary, but they solve the problem at different layers.

Browserbase supports both. Sessions solve supported CAPTCHAs automatically, and Verified gives agents a way to present identity so they earn access to protected sites through Agent Identity standards like Web Bot Auth, rather than fighting the same challenge on every run. For the longer story of how CAPTCHAs got here and why identity is where this is heading, see The CAPTCHA arms race.

When should you use a CAPTCHA solver?

Use CAPTCHA solving for workflows that users and website owners authorize, where a challenge stands between your automation and a legitimate task. Respect each site's terms, honor its access controls, and prefer an official integration or API when one exists. A solver is a tool for keeping authorized automation running, not for reaching places you are not permitted to go.

Last updated: August 3, 2026