> ## Documentation Index
> Fetch the complete documentation index at: https://docs.browserbase.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent Auth & Identity

> How Browserbase works with bot protection providers to give your agents verified access to the web.

<CardGroup cols={2}>
  <Card title="Verified" icon="shield-check" href="/platform/identity/verified-customization">
    Use Browserbase's purpose-built Chromium browser with real fingerprints for maximum success rates.
  </Card>

  <Card title="Proxies" icon="server" href="/platform/identity/proxies">
    Route automation traffic through residential or datacenter proxies for greater reliability.
  </Card>

  <Card title="Authentication management" icon="lock" href="/platform/identity/authentication">
    Handle 2FA, OAuth flows, and other authentication challenges in automated sessions.
  </Card>

  <Card title="IP Allowlisting" icon="network-wired" href="/platform/identity/vpn">
    Route Browserbase traffic through your VPN by allowlisting proxy IPs.
  </Card>
</CardGroup>

## Overview

Automated browsers perform legitimate tasks like testing, data collection, and content aggregation - but bot protection systems often block all automation by default, regardless of intent. Browserbase solves this through direct partnerships with leading bot protection providers.

Rather than trying to evade detection, **Verified** browsers are recognized as legitimate by the protection systems themselves. This means higher success rates, fewer interruptions, and a more reliable automation experience.

## Verified

<Note>
  Verified is available for Scale Plan customers. Reach out to
  [hello@browserbase.com](mailto:hello@browserbase.com) if you're interested in
  learning more, trialing the feature, or upgrading.
</Note>

Verified sessions use a purpose-built Chromium browser, maintained by the Browserbase team, with real browser fingerprints that are recognized by Browserbase's bot protection partners. This provides significantly higher success rates than standard browser sessions.

**Key benefits:**

* Bot protection partners recognize sessions as legitimate
* Significantly fewer CAPTCHA challenges
* Reliable access to protected sites
* Real browser fingerprints - not randomly generated configurations

<Tabs>
  <Tab title="Node.js">
    ```typescript SDK theme={null}
    import Browserbase from "@browserbasehq/sdk";

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

    const session = await bb.sessions.create({
      browserSettings: {
        verified: true,
      },
      proxies: true,
    });
    console.log(session);
    ```
  </Tab>

  <Tab title="Python">
    ```python SDK theme={null}
    from browserbase import Browserbase
    import os

    bb = Browserbase(api_key=os.environ["BROWSERBASE_API_KEY"])

    session = bb.sessions.create(
        proxies=True,
        browser_settings={
            "verified": True,
        },
    )
    print(session)
    ```
  </Tab>
</Tabs>

## Identity & Signed Agents

Identity takes this further through cryptographic authentication. Browserbase partners with leading identity and trust providers so your agents can prove they are legitimate, human-authorized, and operating with consent.

### Web Bot Auth (Cloudflare)

Through Browserbase's partnership with Cloudflare's Signed Agents program, your sessions can prove they are legitimate user-authorized agents — giving website owners the ability to specifically allow Browserbase sessions.

* Authenticated by bot protection partners via Web Bot Auth
* Website owners can explicitly allow Browserbase sessions
* No CAPTCHA challenges on participating sites
* Built on open standards for agent authentication

<Card title="Get Access" icon="rocket" href="https://www.browserbase.com/contact-web-bot-auth">
  Request beta access to enable Web Bot Auth for your account.
</Card>

### Human verification (AgentKit by Tools for Humanity)

For permissionless access via the [x402 protocol](/integrations/x402/introduction), agents can prove they're backed by a real human using [AgentKit](https://docs.world.org/agents/agent-kit) from Tools for Humanity. Instead of API keys or KYC, your agent signs a cryptographic proof linked to a verified human identity on [World Chain](https://world.org/world-chain).

* Proof-of-humanity without revealing personal identity
* Unlocks Verified browsers on x402 sessions
* One-time wallet registration, reusable across sessions
* Silent fallback — unverified agents still get a working browser

<Card title="Set up AgentKit" icon="fingerprint" href="/integrations/x402/agentkit">
  Learn how to prove your agent is human-backed via x402
</Card>

### The identity ladder

Browserbase supports multiple layers of agent identity, each appropriate for different trust levels:

| Layer                 | Mechanism                                                                                  | Trust level                               |
| --------------------- | ------------------------------------------------------------------------------------------ | ----------------------------------------- |
| **API key**           | Browserbase SDK with project credentials                                                   | Account-level (you manage who has keys)   |
| **Credential vaults** | [1Password](/integrations/1password/introduction) integration for secure credential access | Delegated (agent accesses what you allow) |
| **Signed agents**     | Cloudflare Web Bot Auth                                                                    | Cryptographic (websites opt in to allow)  |
| **Human-verified**    | [AgentKit](/integrations/agentkit/introduction) on x402                                    | Cryptographic proof-of-humanity           |

Each layer builds on the previous. An agent using x402 with AgentKit has proven: it can pay (wallet with funds), it's human-backed (AgentBook registration), and it's accessing a legitimate browser (Browserbase Verified).

## CAPTCHA solving

Through Browserbase's partnerships with CAPTCHA providers, Browserbase can resolve challenges automatically so your sessions continue without interruption. CAPTCHA solving is enabled by default for all sessions.

**How it works**

* Solving can take up to 30 seconds, depending on the challenge type.
* Pairing with [proxies](/platform/identity/proxies) improves success rates.
* For non-standard CAPTCHAs, you can provide custom selectors to guide the process.

To disable CAPTCHA solving, set `solveCaptchas` to `false` in `browserSettings` when [creating a session](/platform/browser/getting-started/create-browser-session).

### CAPTCHA solving events

Browserbase emits a console log when it detects a CAPTCHA and begins solving. Listen to these events to wait until solving completes before continuing your automation.

<Tabs>
  <Tab title="Node.js">
    <CodeGroup>
      ```typescript Playwright theme={null}
      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");
        }
      });
      ```

      ```typescript Selenium theme={null}
      // Replace your existing Builder configuration with this code
      const driver = new Builder()
        .withCapabilities({
          browserName: "chrome", // add browser name
          "goog:loggingPrefs": {
            driver: "ALL", // add driver logs
          },
        })
        .usingHttpAgent(customHttpAgent)
        .usingServer(session.seleniumRemoteUrl)
        .build();

      // Add this code where you want to check for CAPTCHA solving
      const driverLogs = await driver.manage().logs().get("driver");

      // Example check for CAPTCHA solving events
      driverLogs
        .filter((log) => log.message.includes("browserbase-solving"))
        .forEach((log) => console.log(log.message));
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Python">
    <CodeGroup>
      ```python Playwright theme={null}
      # Add this code where you want to check for CAPTCHA solving
      def handle_console(msg):
          if msg.text == "browserbase-solving-started":
              print("Captcha Solving In Progress")
          elif msg.text == "browserbase-solving-finished":
              print("Captcha Solving Completed")

      page.on("console", handle_console)
      ```

      ```python Selenium theme={null}
      # Configure logging preferences when creating the driver
      options = webdriver.ChromeOptions()
      options.set_capability("goog:loggingPrefs", {"driver": "ALL"})
      driver = webdriver.Remote(command_executor=session.selenium_remote_url, options=options)

      # Add this code where you want to check for CAPTCHA solving
      logs = driver.get_log("driver")
      for log in logs:
          if "browserbase-solving-started" in log["message"]:
              print("Captcha Solving In Progress")
          elif "browserbase-solving-finished" in log["message"]:
              print("Captcha Solving Completed")
      ```
    </CodeGroup>
  </Tab>
</Tabs>

### Custom CAPTCHA solving

If you encounter a non-standard, or custom CAPTCHA provider, you need to specify the explicit selector for the CAPTCHA image and button itself.

For this custom CAPTCHA provider, you'll need to specify two CSS selectors:

<Steps>
  <Step title="The selector for the CAPTCHA image element">
    <img src="https://mintcdn.com/browserbase/m1Ny8qOvNHvtrY7y/images/features/custom-captcha.png?fit=max&auto=format&n=m1Ny8qOvNHvtrY7y&q=85&s=28c7563f272fab14a2a4822500ada092" alt="" width="450" height="124" data-path="images/features/custom-captcha.png" />
  </Step>

  <Step title="Right-click on the CAPTCHA image and select 'Inspect' then pull the 'id' from the HTML source code of the image">
    ```html theme={null}
    <img class="LBD_CaptchaImage" id="c_turingtestpage_ctl00_maincontent_captcha1_CaptchaImage" src="/BotDetectCaptcha.ashx?get=image&amp;c=c_turingtestpage_ctl00_maincontent_captcha1&amp;t=759cbf332a684ae3abe16213fe76438c" alt="CAPTCHA">
    ```

    The id in this example is `c_turingtestpage_ctl00_maincontent_captcha1_CaptchaImage`
  </Step>

  <Step title="The selector for the input field where the solution should be entered">
    <img src="https://mintcdn.com/browserbase/m1Ny8qOvNHvtrY7y/images/features/captcha-input.png?fit=max&auto=format&n=m1Ny8qOvNHvtrY7y&q=85&s=84649199696e32f8f46a0f469655ff23" alt="" width="450" height="78" data-path="images/features/captcha-input.png" />
  </Step>

  <Step title="Right-click on the input field and select 'Inspect' then pull the 'id' from the HTML source code of the input field">
    ```html theme={null}
    <input name="ctl00$MainContent$txtTuringText" type="text" value="Enter the characters shown above" maxlength="6" id="ctl00_MainContent_txtTuringText" class="swap_value field" initialvalue="Enter the characters shown above" title="Enter the characters shown above">
    ```

    The id in this example is `ctl00_MainContent_txtTuringText`
  </Step>

  <Step title="Configure your browser settings with these selectors">
    ```javascript theme={null}
    browserSettings: {
      captchaImageSelector: "#c_turingtestpage_ctl00_maincontent_captcha1_CaptchaImage",
      captchaInputSelector: "#ctl00_MainContent_txtTuringText"
    }
    ```
  </Step>
</Steps>

### Disabling CAPTCHA solving

CAPTCHA solving typically takes between 5 and 30 seconds.

If you'd like to disable captcha solving, you can set `solveCaptchas` to `false` in the `browserSettings` when creating a session.

<Tabs>
  <Tab title="Node.js">
    ```javascript SDK theme={null}
    import Browserbase from "@browserbasehq/sdk";

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

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

    const session = await createSessionWithoutCaptchaSolving();
    console.log(session);
    ```
  </Tab>

  <Tab title="Python">
    ```python SDK theme={null}
    from browserbase import Browserbase
    import os

    bb = Browserbase(api_key=os.environ["BROWSERBASE_API_KEY"])

    def createSessionWithoutCaptchaSolving():
        session = bb.sessions.create(
            browser_settings={
              "solveCaptchas": False,
            }
        )
        return session

    session = createSessionWithoutCaptchaSolving()
    print(session)
    ```
  </Tab>
</Tabs>

## Best practices

Follow these best practices to ensure stable, efficient, and responsible automation with Browserbase.

### Site compliance & ethical automation

Before automating a website:

* Review the site's **terms of service** to ensure compliance.
* Check **robots.txt** for crawling guidelines when applicable.
* Cache responses **to reduce unnecessary requests** and improve efficiency.

Need help? Contact [support@browserbase.com](mailto:support@browserbase.com)