How to Bypass CAPTCHA in Chrome Using the 2Captcha API v2

CAPTCHAs protect websites, but sometimes they get in the way of legitimate automation tasks. Are you doing web scraping, testing, or building bots? Then this guide is for you.

I will show you three main ways to solve CAPTCHAs in Chrome using our service: via Postman with no code, through our browser extension, and via direct API calls. At the end, I will add a bonus for Puppeteer and Node.js users.

What you will need

• An account with our service and an API key
• Chrome browser
• Python or Node.js, depending on your chosen method
• 5 to 10 minutes for setup

CAPTCHA types we support

Our service works with most popular protection types.

Core types

• Simple text CAPTCHA
• reCAPTCHA V2, V3, Enterprise
• Cloudflare Turnstile
• Arkose Labs CAPTCHA (FunCaptcha)
• GeeTest, GeeTest V4

Interactive and visual

• Rotate CAPTCHA, Click CAPTCHA, Grid CAPTCHA
• Draw Around, Bounding box, Coordinates
• Capy Puzzle CAPTCHA, KeyCAPTCHA, Lemin CAPTCHA
• Amazon CAPTCHA, VK CAPTCHA, Tencent

Other formats

• Audio CAPTCHA, CyberSiARA, MTCaptcha
• DataDome CAPTCHA, Friendly CAPTCHA, CutCAPTCHA
• atbCAPTCHA, Prosopo Procaptcha, CAPTCHAFox
• Altcha CAPTCHA, Temu CAPTCHA

If your CAPTCHA is on this list, chances are we can solve it automatically.

Method 1. Quick and code-free: solve CAPTCHAs via Postman

Need to test CAPTCHA solving or make a one-off request without writing a script? Use Postman. This is a great way to check how everything works before moving to full automation in Chrome.

Step by step

1. Open our service documentation and find the request example for your CAPTCHA type
2. Copy the example into Postman, import via raw JSON or cURL
3. Fill in your values:
   • clientKey — your API key from the dashboard
   • websiteURL — the page URL with the CAPTCHA in Chrome
   • websiteKey — the CAPTCHA sitekey, I will show you how to find it below
4. Send the request and wait for the response
5. Copy the token from the solution field and use it on the target website

Example request for reCAPTCHA V2

{
  "clientKey": "your_key",
  "task": {
    "type": "RecaptchaV2TaskProxyless",
    "websiteURL": "https://example.com",
    "websiteKey": "6Lc..._sitekey"
  }
}

How to get the solution

After creating a task, you will receive a taskId. Use it to check the status:

{
  "clientKey": "your_key",
  "taskId": "1234567890"
}

When the response shows "status": "ready", grab the token from solution.gRecaptchaResponse.

Where to insert the token

For reCAPTCHA V2 and V3, the token usually goes into a hidden field called g-recaptcha-response. Open DevTools in Chrome, press F12, go to the Console tab, and run:

document.getElementById('g-recaptcha-response').textContent = 'YOUR_TOKEN'

Then click the form submit button on the page.

Keep in mind, this token injection method does not work everywhere. We showed the most common case, but each CAPTCHA has its own quirks. For other protection types, you may need to experiment: solve the CAPTCHA manually a few times, see where the site expects the answer, and adjust your script to match the required structure.

Why Postman is convenient

• No coding needed, everything is set up in the interface
• Requests can be saved to a collection and reused
• Easy to test different CAPTCHA types by changing just a few parameters
• You can see the request and response structure clearly, which helps with debugging
• Works independently of the browser, so you can test in Chrome at the same time

When to use this method

• Quick check to see if the service works with your CAPTCHA type
• Debugging before writing a Python or Node.js script
• One-off tasks when you do not want to set up a full environment
• Testing proxies or request parameters

Limitations

• Not suitable for bulk tasks, you create each request manually
• No automation, you copy tokens yourself
• Requires switching between Postman and the browser

This method is the perfect starting point. Begin with Postman to understand the API workflow. When your tasks become regular, move to the extension or direct code integration.

Method 2. Automation via the Captcha Solver extension

Ideal if you need to solve CAPTCHAs directly in the browser without writing complex scripts.

Installation and setup

1. Install the extension from the Chrome Web Store
2. Open settings and paste your API key
3. Go to a site with a CAPTCHA, the extension will detect it automatically
4. The solution will be inserted into the form, you just need to submit the data

Key extension settings

• Enable plugin: turns page analysis on or off
• Auto-submit forms: convenient, but use with caution. If form validation fails, the extension might loop and resubmit the CAPTCHA
• Form submission delay: give the page time to process before auto-submitting
• Retry on error: useful for unstable connections
• Use proxy: if the site blocks by IP, specify a proxy in login:password@ip:port format or ip:port for proxies without auth

Two working modes for each CAPTCHA type

• Enabled: the extension looks for this CAPTCHA type on the page
• Solve automatically: if enabled, the CAPTCHA is sent for solving right away. If disabled, a "Solve" button appears for manual triggering

For image CAPTCHAs

The extension does not know where the CAPTCHA image is or where to insert the answer. Set it up manually:

1. Right-click the CAPTCHA image, select "solve this CAPTCHA"
2. Click the answer input field, select "Insert CAPTCHA answer here"
3. The setting is saved for the entire site

Important technical note

CAPTCHA tokens are valid for about 120 seconds. After receiving a solution, use it within 115 to 117 seconds, or you will need to solve it again.

Example with Selenium

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_extension('path/to/CaptchaSolver.crx')
options.add_argument('--disable-blink-features=AutomationControlled')
driver = webdriver.Chrome(options=options)

driver.get('https://example.com')
# The extension will solve the CAPTCHA automatically, just wait and submit the form

Pros: quick setup, works in a real browser, minimal code.

Cons: requires Chrome to be open, less flexibility for complex scenarios, the extension may not detect CAPTCHAs on all sites.

Method 3. Full automation via API

Maximum control and scalability. Suitable for production and large projects.

Basic request without proxy

import requests
import time

API_KEY = 'your_key'
create_task_url = 'https://api.service.com/createTask'
get_result_url = 'https://api.service.com/getTaskResult'

data = {
    "clientKey": API_KEY,
    "task": {
        "type": "RecaptchaV2TaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "site_key_of_the_captcha"
    }
}

response = requests.post(create_task_url, json=data).json()
task_id = response['taskId']

# Wait for solution
while True:
    result = requests.post(get_result_url, json={
        "clientKey": API_KEY,
        "taskId": task_id
    }).json()
    
    if result['status'] == 'ready':
        solution = result['solution']['gRecaptchaResponse']
        break
    time.sleep(5)

With proxy, if the site blocks by IP

proxy_config = {
    "type": "HTTPS",
    "address": "proxy.example.com",
    "port": 1234,
    "login": "user",
    "password": "pass"
}

data["task"].update({
    "type": "RecaptchaV2Task",
    "proxyType": proxy_config["type"],
    "proxyAddress": proxy_config["address"],
    "proxyPort": proxy_config["port"],
    "proxyLogin": proxy_config.get("login"),
    "proxyPassword": proxy_config.get("password")
})

Integration with Selenium

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get('https://example.com')

# Insert the received solution
script = f"document.getElementById('g-recaptcha-response').innerHTML = '{solution}';"
driver.execute_script(script)

# Emulate click on the submit button
driver.execute_script("document.getElementById('submit-button').click();")

driver.quit()

Pros: full automation, proxy support, scalability.

Cons: requires coding, slightly more complex setup.

How to find the sitekey for reCAPTCHA

Without the correct sitekey, the CAPTCHA will not solve. Here is how to find it.

Via Developer Tools

1. Open the site with the CAPTCHA in Chrome
2. Press F12 or Ctrl+Shift+I to open DevTools
3. Go to the "Elements" tab
4. Find a block with class g-recaptcha or similar
5. Inside, find the data-sitekey attribute

Example code:

<div class="g-recaptcha" data-sitekey="6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI"></div>

The value in data-sitekey is your sitekey.

Via the extension detector

If the extension is installed:

1. Open DevTools on the CAPTCHA page
2. Go to the CAPTCHA detector tab
3. In the parameters table, find the row "Google reCAPTCHA site-key"
4. Copy the value

Other CAPTCHA types may also require a sitekey or similar identifier for submission. There are many ways to find them, so we are only showing the reCAPTCHA example here.

Bonus. Automation with Puppeteer and the extension

If you work with Node.js, Puppeteer gives you a powerful tool for browser control. Paired with the Captcha Solver extension, you get convenient CAPTCHA automation.

Step 1. Install dependencies

npm i puppeteer puppeteer-extra puppeteer-extra-plugin-stealth

Step 2. Configure the extension

1. Download and extract the extension to ./CaptchaSolver in your project root
2. Open ./common/config.js and set your API key in the apiKey field
3. For auto-solving reCAPTCHA v2, set autoSolveRecaptchaV2 to true
4. To prevent the extension from opening settings on launch, remove the options_ui block from manifest.json

Step 3. Launch Puppeteer with the extension

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
const { executablePath } = require('puppeteer');
const path = require('path');

(async () => {
  const pathToExtension = path.join(__dirname, 'CaptchaSolver');
  
  puppeteer.use(StealthPlugin());
  
  const browser = await puppeteer.launch({
    headless: false,
    args: [
      `--disable-extensions-except=${pathToExtension}`,
      `--load-extension=${pathToExtension}`,
    ],
    executablePath: executablePath()
  });
  
  const [page] = await browser.pages();
  
  // Navigate to the CAPTCHA page
  await page.goto('https://example.com');
  
  // Wait for the extension button and click to send the CAPTCHA
  await page.waitForSelector('.captcha-solver');
  await page.click('.captcha-solver');
  
  // Wait for CAPTCHA solution (3 minute timeout)
  await page.waitForSelector('.captcha-solver[data-state="solved"]', {timeout: 180000});
  
  // CAPTCHA solved, proceed with further actions
  await page.click('button[type="submit"]');
  
  await browser.close();
})();

How to track solving status

The extension changes the data-state attribute on the .captcha-solver button:

• ready: extension is ready, you can send the CAPTCHA
• solving: CAPTCHA is being solved
• solved: solution received, you can continue
• error: an error occurred, retry needed

Useful tips for Puppeteer

• Headless mode does not support extensions. If you need headless, use xvfb or run in normal mode
• For debugging, enable sandbox mode in the extension settings, then CAPTCHAs will come to you for verification
• Use puppeteer-extra-plugin-stealth to hide automation signs and reduce bot detection risk

Pros: powerful browser control, suitable for complex scenarios, works with Node.js.

Cons: requires extension setup, does not work in headless mode without extra tools.

Pre-launch checklist

• Check that your API key is active
• Make sure all parameters are correct
• For API, add small delays between requests
• Use proxies when making many requests from one IP
• Test your script in debug mode before running in production
• For the extension: configure auto-form submission carefully to avoid loops

Which method to choose

• One-off tasks and testing: go with Postman
• Quick browser automation: use the extension
• Large projects and scraping: connect via API
• Node.js work and complex scenarios: use Puppeteer with the extension

Our service gives you flexibility: start simple, scale up as your tasks grow. Documentation and code examples are available on our website.

Automate smart, respect website rules, and remember to add delays between requests. If you have questions, reach out to support via the form on our site.

Good luck with your setup.