Skip to main content
reCAPTCHA Bypass

Bypass reCAPTCHA with Puppeteer

Automatically solve reCAPTCHA v2 and v3 challenges in your Puppeteer scripts. Built-in CAPTCHA solving, stealth mode, and fingerprint evasion for reliable automation.

The reCAPTCHA Challenge

Why solving CAPTCHAs with Puppeteer is difficult

Bot Detection
Google's reCAPTCHA uses advanced fingerprinting to identify Puppeteer, Selenium, and other automation tools, blocking your scripts before they even start.
Complex Integration
Integrating third-party CAPTCHA solving services means managing API keys, handling callbacks, polling for results, and dealing with timeout errors.
Time Consuming
Each CAPTCHA can take 15-45 seconds to solve, multiplied across hundreds or thousands of requests. This drastically slows down your automation.

The Browserless Solution

Automated reCAPTCHA bypass with zero configuration

Stealth Mode Enabled
Browserless automatically masks Puppeteer fingerprints, making your automation appear as a real browser. WebDriver flags removed, canvas fingerprinting blocked.
Automatic CAPTCHA Solving
Built-in integration with leading CAPTCHA solving services. reCAPTCHA v2, v3, and invisible CAPTCHAs solved automatically with one connection flag.
Seamless Automation
Your Puppeteer code keeps its shape. CAPTCHAs are detected and solved in the background; wait on the solved event only before the step that depends on it.

Simple Puppeteer Code

No complex CAPTCHA solving logic needed - just write normal Puppeteer code

Without Browserless - Complex Setup
Manual CAPTCHA solving requires extensive boilerplate code
import puppeteer from 'puppeteer';
import { solveCaptcha } from 'some-captcha-service';

const browser = await puppeteer.launch();
const page = await browser.newPage();

// Navigate to page with reCAPTCHA
await page.goto('https://example.com/login');

// Detect CAPTCHA
const captchaExists = await page.$('.g-recaptcha');

if (captchaExists) {
  // Extract site key
  const siteKey = await page.$eval(
    '.g-recaptcha',
    el => el.getAttribute('data-sitekey')
  );

  // Call external CAPTCHA solving service
  const solution = await solveCaptcha({
    siteKey,
    url: page.url(),
    apiKey: process.env.CAPTCHA_API_KEY
  });

  // Wait for solution (can take 30+ seconds)
  const token = await solution.waitForToken();

  // Inject token into page
  await page.evaluate((token) => {
    document.getElementById('g-recaptcha-response').innerHTML = token;
  }, token);

  // Submit form
  await page.click('button[type="submit"]');
}

// Continue automation...
await browser.close();
With Browserless - Zero Configuration
CAPTCHAs are automatically detected and solved
import puppeteer from 'puppeteer-core';

// solveCaptchas turns on background solving; the longer timeout gives a solve room to finish
const browser = await puppeteer.connect({
  browserWSEndpoint: 'wss://production-sfo.browserless.io?token=YOUR_API_KEY&solveCaptchas=true&timeout=300000'
});

const page = await browser.newPage();
const cdp = await page.createCDPSession();

// Browserless reports a detected reCAPTCHA, then the result of its background solve
const captchaFound = new Promise((resolve) =>
  cdp.once('Browserless.captchaFound', () => resolve(true))
);
const captchaSolved = new Promise((resolve) =>
  cdp.once('Browserless.captchaAutoSolved', resolve)
);

// Navigate to page with reCAPTCHA
await page.goto('https://example.com/login', {
  waitUntil: 'networkidle2',
  timeout: 60000,
});

// Fill in the login form while Browserless solves the reCAPTCHA in the background
await page.type('#username', 'user@example.com');
await page.type('#password', 'password123');

// Submit only once a detected reCAPTCHA has been solved
const found = await Promise.race([
  captchaFound,
  new Promise((resolve) => setTimeout(() => resolve(false), 5000)),
]);
if (found) {
  const { solved, error } = await captchaSolved;
  if (!solved) throw new Error(error || 'reCAPTCHA was not solved');
}
await page.click('button[type="submit"]');

// Continue automation...
await page.waitForNavigation();
const data = await page.evaluate(() => {
  return document.querySelector('.dashboard-data').textContent;
});

await browser.close();

console.log('Data:', data);
Advanced Example: CAPTCHAs on Later Pages
Catch a CAPTCHA that appears after a navigation, not only on the first page
import puppeteer from 'puppeteer-core';

const browser = await puppeteer.connect({
  browserWSEndpoint: 'wss://production-sfo.browserless.io?token=YOUR_API_KEY&solveCaptchas=true&timeout=300000'
});

const page = await browser.newPage();
const cdp = await page.createCDPSession();

// Arm the listeners before the first navigation: once() captures the first CAPTCHA
// detected anywhere in the session, even on a later page. Arm a fresh pair before
// each additional CAPTCHA you need to wait on.
const captchaFound = new Promise((resolve) =>
  cdp.once('Browserless.captchaFound', () => resolve(true))
);
const captchaSolved = new Promise((resolve) =>
  cdp.once('Browserless.captchaAutoSolved', resolve)
);

// First page: no reCAPTCHA here
await page.goto('https://example.com/account', {
  waitUntil: 'networkidle2',
  timeout: 60000,
});

// Click through to a form guarded by reCAPTCHA; detection fires as it loads
await page.click('a[href="/account/support"]');
await page.waitForNavigation({ waitUntil: 'networkidle2' });
await page.type('#message', 'Hello from an automated test');

// Submit only once a detected reCAPTCHA has been solved
const found = await Promise.race([
  captchaFound,
  new Promise((resolve) => setTimeout(() => resolve(false), 5000)),
]);
if (found) {
  const { solved, error } = await captchaSolved;
  if (!solved) throw new Error(error || 'reCAPTCHA was not solved');
}
await page.click('button[type="submit"]');
await page.waitForNavigation();

await browser.close();

Comprehensive CAPTCHA Coverage

Support for all major CAPTCHA types and services

reCAPTCHA v2
Automatically solves reCAPTCHA v2 checkbox challenges. Works with both the simple checkbox and image selection puzzles.
reCAPTCHA v3
Handles reCAPTCHA v3's invisible verification system. Maintains high trust scores through realistic browser behavior and fingerprints.
Invisible reCAPTCHA
Automatically handles invisible reCAPTCHA that triggers on form submission or button clicks. No manual intervention required.
GeeTest
Solves GeeTest challenges automatically with the same built-in solving used for reCAPTCHA.
Enterprise reCAPTCHA
Handles enterprise reCAPTCHA implementations with custom configurations and advanced fraud detection systems.
Cloudflare Turnstile
Automatically bypasses Cloudflare Turnstile challenges through stealth mode and advanced fingerprint evasion techniques.

Why Choose Browserless for CAPTCHA Bypass?

Zero Configuration
No API keys to manage, no external services to integrate. CAPTCHA solving works out of the box with your existing Puppeteer code.
Pay Only for Successful Solves
reCAPTCHA v2, v3 and invisible challenges are detected and solved automatically. Realistic browser behavior reduces how often challenges appear at all, and attempts that don't clear aren't charged.
Fast Solving
Solves typically finish in seconds to a minute depending on the challenge. Solving runs in the background, so raise the session timeout, and before the step that needs the solve, wait for the solved event and check that it reports solved.
Cost Effective
Included in your Browserless plan with no separate solving service to subscribe to. Each successful solve uses 10 units on top of browser time; attempts that don't clear aren't charged.
Stealth First
Built-in fingerprint randomization and WebDriver detection evasion means many sites won't even trigger CAPTCHAs.
Automatic Detection
Automatically detects when a CAPTCHA appears and handles it in the background. No need to check for CAPTCHA presence manually.
Secure & Reliable
Enterprise-grade infrastructure with 99.9% uptime. Your CAPTCHA solving runs on secure, isolated browser instances.
Always Updated
We keep pace with CAPTCHA changes so your automations keep running reliably.
Real-Time Monitoring
Monitor your CAPTCHA solving with detailed logs and analytics to track success rates and performance.

Common Use Cases

Browserless is built for automating systems you own or are authorized to access.

E2E Testing
Run end-to-end tests on forms and workflows protected by reCAPTCHA. Verify complete user journeys without disabling security.
Web Scraping
Collect data from CAPTCHA-protected websites at scale. Perfect for price monitoring, market research, and competitive analysis.
Price Monitoring
Monitor public pricing pages at scale. Collect market data without manual intervention.
SEO Monitoring
Track search rankings and crawl protected websites. Collect comprehensive SEO data.

How It Works Behind the Scenes

Multi-layered approach for reliable CAPTCHA bypass

1

Stealth Mode Activation

When your Puppeteer script connects to Browserless, stealth mode is automatically enabled. This removes all WebDriver flags, randomizes browser fingerprints, and masks automation signatures that trigger CAPTCHA challenges.

2

CAPTCHA Detection

As your script navigates pages, Browserless continuously monitors for CAPTCHA elements. When a reCAPTCHA or other challenge is detected, the solving process initiates automatically in the background.

3

Automatic Solving

The CAPTCHA is solved using a combination of techniques: advanced computer vision for image challenges, machine learning models, and when needed, integration with professional solving services. The solution is injected seamlessly.

4

Seamless Continuation

Once solved, the token is already in the page and your script carries on from the step that was waiting on it. No polling a solving service, no callback plumbing, no manual intervention.

Start Bypassing reCAPTCHA Today

Add automatic CAPTCHA solving to your Puppeteer scripts with zero configuration. The free plan includes 1,000 units, with CAPTCHA solving included.