使用 Puppeteer 和 Playwright 绕过复杂 CAPTCHA

Puppeteer

我们将使用 VS Code 作为开发环境，因此本指南将专注于此环境下的操作。所有代码示例将在不使用代理的情况下运行。如果需要指定代理，只需在创建任务时额外指定代理参数和当前的 User-Agent，例如：

  "clientKey":"YOUR_API_KEY",
  "task": {
    "type":"RecaptchaV2Task",
    "websiteURL":"https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high",
    "websiteKey":"EXAMPLE_SITE_KEY",
    "proxyType":"http",
    "proxyAddress":"8.8.8.8",
    "proxyPort":8080,
    "proxyLogin":"proxyLoginHere",
    "proxyPassword":"proxyPasswordHere",
    "userAgent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"

因此，要安装 Puppeteer，你需要按照以下步骤进行：

安装 Node.js：Puppeteer 需要 Node.js，因此请确保你安装了最新版本。
创建项目：如果还没有项目目录，请为你的项目创建一个新的目录。
初始化 Node.js：在 VS Code 中打开终端（按 Ctrl + ~ 打开集成终端），进入你的目录并运行 npm init，然后按照终端中的提示操作。此命令会初始化一个新的 Node.js 项目并创建一个 package.json 文件。所有安装的依赖项都会显示在这个文件中。
安装 Puppeteer：在 VS Code 终端中运行 npm install puppeteer，将 Puppeteer 和它的依赖项下载到你的项目中。

现在你需要安装一个便于发送和接收 HTTP 请求的库。CapMonster Cloud 提供了自己的库，我们将在示例中使用它。使用以下命令安装该库：npm i @zennolab_com/capmonstercloud-client。

ReCaptcha v.2

你需要找出 CAPTCHA 的 sitekey 和其他必要的数据，以便成功发送请求、接收答案并将 token 插入到 CAPTCHA 元素中。所有这些信息都可以在开发者工具的代码中找到。还请务必查看官方的 CapMonster Cloud 文档。

让我们在 JavaScript 中创建一个新项目，并导入所有必要的依赖项：

import { launch } from 'puppeteer';
import { CapMonsterCloudClientFactory, ClientOptions, RecaptchaV2ProxylessRequest } from '@zennolab_com/capmonstercloud-client';

接下来，设置这些值（顺便说一下，为了方便并避免数据泄露，最好在同一目录下创建一个单独的 .env 文件，并将所有这些数据写入其中，在代码中使用 dotenv 库来导入和使用这些数据）：

const CAPMONSTER_API_KEY = 'YOUR_API_KEY';
const WEBSITE_KEY = 'EXAMPLE_SITE_KEY';
const WEBSITE_URL = 'https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high';

让我们创建一个任务，将其发送到 CapMonster Cloud 服务器，获取解决方案，并将 token 插入到 CAPTCHA 表单中：

async function solveRecaptcha() {
  const browser = await launch({ headless: false });
  const page = await browser.newPage();

  // Initializing the CapMonster client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));

  try {
    await page.goto(WEBSITE_URL);
    console.log('Page open, reCAPTCHA solving...');

    // Creating a request for a reCAPTCHA solving type V2 Proxyless
    const recaptchaV2ProxylessRequest = new RecaptchaV2ProxylessRequest({
      websiteURL: WEBSITE_URL,
      websiteKey: WEBSITE_KEY,
    });

    // reCAPTCHA solving using CapMonster
    const solution = await cmcClient.Solve(recaptchaV2ProxylessRequest);
    console.log('Solution from CapMonster:', solution);

    // Retrieving a token from a solution object
    const token = solution.solution.gRecaptchaResponse;

    // Inserting the result into a form
    await page.evaluate((result) => {
      document.getElementById('g-recaptcha-response').value = result;
      console.log('Token in the console:', result); // Output the token to the console
    }, token);

    console.log('The token is inserted into the form!');

    await page.click('#recaptcha-demo-submit');
    console.log('Form submitted!'); // Optional step

    await new Promise(resolve => setTimeout(resolve, 10000));

  } catch (error) {
    console.error('Error:', error);
  } finally {
    await browser.close();
  }
}

solveRecaptcha();

代码解释：

async function solveRecaptcha() {...}: 声明一个异步的 `solveRecaptcha` 函数，包含所有代码逻辑。

const browser = await launch({ headless: false });: 使用 Puppeteer 启动浏览器。`headless: false` 选项表示浏览器将以图形界面启动（而不是在后台运行）。

const page = await browser.newPage();: 在浏览器中创建一个新标签页。

const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));: 使用提供的 API 密钥初始化 CapMonster 客户端。

await page.goto(WEBSITE_URL);: 跳转到指定的网站。

const recaptchaV2ProxylessRequest = new RecaptchaV2ProxylessRequest({ ... });: 创建一个 reCAPTCHA V2 Proxyless 类型的请求对象。这里设置了诸如网站 URL 和 reCAPTCHA 密钥等参数。

const solution = await cmcClient.Solve(recaptchaV2ProxylessRequest);: 向 CapMonster 发送请求解决 reCAPTCHA。结果保存在 `solution` 对象中。

const token = solution.solution.gRecaptchaResponse;: 从 CapMonster 的解决方案对象中获取 token（reCAPTCHA 响应）。

await page.evaluate((result) => {...}, token);: 使用 Puppeteer 的 `evaluate` 方法将 token 插入到网页中的表单。

await page.click('#recaptcha-demo-submit');: 点击具有指定选择器的按钮（在此情况下是 id 为 `recaptcha-demo-submit` 的按钮）。

await new Promise(resolve => setTimeout(resolve, 10000));: 使用 Promise 暂停 10 秒钟（此处为暂停）。

} catch (error) { console.error('Error:', error); } finally { await browser.close(); }}: 错误处理（如果有的话）并在 `finally` 块中关闭浏览器。

solveRecaptcha();: 调用 `solveRecaptcha` 函数来完成整个过程。

完整代码：

import { launch } from 'puppeteer';
import { CapMonsterCloudClientFactory, ClientOptions, RecaptchaV2ProxylessRequest } from '@zennolab_com/capmonstercloud-client';

const CAPMONSTER_API_KEY = 'YOUR_API_KEY';
const WEBSITE_KEY = 'EXAMPLE_SITE_KEY';
const WEBSITE_URL = 'https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high';

async function solveRecaptcha() {
  const browser = await launch({ headless: false });
  const page = await browser.newPage();

  // Initializing the CapMonster client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));

  try {
    await page.goto(WEBSITE_URL);
    console.log('Page is open, reCAPTCHA solving...');

    // Creating a request for a reCAPTCHA solving type V2 Proxyless
    const recaptchaV2ProxylessRequest = new RecaptchaV2ProxylessRequest({
      websiteURL: WEBSITE_URL,
      websiteKey: WEBSITE_KEY,
    });

    // reCAPTCHA solving using CapMonster
    const solution = await cmcClient.Solve(recaptchaV2ProxylessRequest);
    console.log('Solution from CapMonster:', solution);

    // Retrieving a token from a solution object
    const token = solution.solution.gRecaptchaResponse;

    // Inserting the result into a form
    await page.evaluate((result) => {
      document.getElementById('g-recaptcha-response').value = result;
      console.log('Token is in the console:', result); // Output the token to the console
    }, token);

    console.log('The token is inserted into the form!');

    await page.click('#recaptcha-demo-submit');
    console.log('Form is submitted!'); // Optional step

    await new Promise(resolve => setTimeout(resolve, 10000));

  } catch (error) {
    console.error('Error:', error);
  } finally {
    await browser.close();
  }
}

solveRecaptcha();

通过终端命令运行代码：node your_project_name.js 或通过调试控制台运行。如果成功，将会打开一个确认页面：

ReCaptcha v.3

导入所有必要的依赖：

import { launch } from 'puppeteer';
import { CapMonsterCloudClientFactory, ClientOptions, RecaptchaV3ProxylessRequest } from '@zennolab_com/capmonstercloud-client';

设置值：

const CAPMONSTER_API_KEY = 'YOUR_API_KEY';
const WEBSITE_KEY = 'EXAMPLE_SITE_KEY';
const WEBSITE_URL = 'https://lessons.zennolab.com/captchas/recaptcha/v3.php?level=beta';

创建一个任务，将其发送到 CapMonster Cloud 服务器，获取解决方案并将 token 插入到 CAPTCHA 表单中：

async function solveRecaptcha() {
  const browser = await launch({ headless: false });
  const page = await browser.newPage();
  console.log('Browser is initialized!');

  // Initializing the CapMonster client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));

  try {
    await page.goto(WEBSITE_URL, {
      waitUntil: 'domcontentloaded'
    });
    console.log('Browser page is switched to captcha page!');

    const recaptchaV3ProxylessRequest = new RecaptchaV3ProxylessRequest({
      websiteURL: WEBSITE_URL,
      websiteKey: WEBSITE_KEY,
      minScore: 0.7,
      pageAction: "verify",
    });

    // Receiving a captcha solution from CapMonster
    const solution = await cmcClient.Solve(recaptchaV3ProxylessRequest);
    console.log('CapMonster Solution:', solution);

    // Installing a custom userAgent (optional)
    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36'); // You can replace it with your own

    await page.evaluate((result) => {
      document.querySelector('#g-recaptcha-response-100000').style.display = 'block';
      document.querySelector('#g-recaptcha-response-100000').style.visibility = 'visible';
      document.querySelector('#g-recaptcha-response-100000').value = result;
    }, solution);

    console.log('Result injected into the page!');

    await Promise.all([
      page.waitForNavigation(),
      page.click('#v3_submit')
    ]);
    console.log('Button "Check" clicked!');

    await new Promise(resolve => setTimeout(resolve, 10000));

  } catch (e) {
    console.error('An error occurred:', e);
  } finally {
    await browser.close();
  }
}

solveRecaptcha();

代码部分解释：

async function solveRecaptcha() {...}: 声明一个异步的 `solveRecaptcha` 函数，包含所有代码逻辑。

const browser = await launch({ headless: false });: 使用 Puppeteer 启动浏览器。`headless: false` 选项表示浏览器将以图形界面启动（而不是在后台运行）。

const page = await browser.newPage();: 创建一个新的浏览器标签页。

console.log('Browser is initialized!');: 输出一条消息到控制台，表示浏览器已初始化。

const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));: 使用提供的 API 密钥初始化 CapMonster 客户端。

await page.goto(WEBSITE_URL);: 跳转到指定的网站。

const recaptchaV3ProxylessRequest = new RecaptchaV3ProxylessRequest({ ... });: 创建一个 reCAPTCHA V3 Proxyless 类型的请求对象。设置了诸如网站 URL 和 reCAPTCHA 密钥等参数。

const solution = await cmcClient.Solve(recaptchaV3ProxylessRequest);: 向 CapMonster 提交请求以解决 reCAPTCHA。结果保存在 `solution` 对象中。

await page.evaluate((result) => {...}, solution);: 使用 Puppeteer 的 `evaluate` 方法将 reCAPTCHA 解决方案插入到网页表单中。

await Promise.all([...]);: 等待导航完成并点击具有指定选择器的按钮。

console.log('Result injected into the page!');: 在控制台显示消息，表示结果已插入到页面中。

await new Promise(resolve => setTimeout(resolve, 10000));: 使用 Promise 暂停 10 秒钟。

} catch (e) { console.error('An error occurred:', e); } finally { await browser.close(); }}: 处理错误（如果有的话），并在 `finally` 块中关闭浏览器。

solveRecaptcha();: 调用 `solveRecaptcha` 函数以完成整个过程。

完整代码：

import { launch } from 'puppeteer';
import { CapMonsterCloudClientFactory, ClientOptions, RecaptchaV3ProxylessRequest } from '@zennolab_com/capmonstercloud-client';

const CAPMONSTER_API_KEY = 'YOUR_API_KEY';
const WEBSITE_KEY = 'EXAMPLE_SITE_KEY';
const WEBSITE_URL = 'https://lessons.zennolab.com/captchas/recaptcha/v3.php?level=beta';

async function solveRecaptcha() {
  const browser = await launch({ headless: false });
  const page = await browser.newPage();
  console.log('Browser is initialized!');

  // Initializing the CapMonster client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));

  try {
    await page.goto(WEBSITE_URL, {
      waitUntil: 'domcontentloaded'
    });
    console.log('Browser page is switched to captcha page!');

    const recaptchaV3ProxylessRequest = new RecaptchaV3ProxylessRequest({
      websiteURL: WEBSITE_URL,
      websiteKey: WEBSITE_KEY,
      minScore: 0.7,
      pageAction: "verify",
    });

    // Getting a captcha solution from CapMonster
    const solution = await cmcClient.Solve(recaptchaV3ProxylessRequest);
    console.log('CapMonster Solution:', solution);

    await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36');

    await page.evaluate((result) => {
      document.querySelector('#g-recaptcha-response-100000').style.display = 'block';
      document.querySelector('#g-recaptcha-response-100000').style.visibility = 'visible';
      document.querySelector('#g-recaptcha-response-100000').value = result;
    }, solution);

    console.log('Result embedded into the page!');

    await Promise.all([
      page.waitForNavigation(),
      page.click('#v3_submit')
    ]);
    console.log('Button "Check" clicked!');

    await new Promise(resolve => setTimeout(resolve, 10000));

  } catch (e) {
    console.error('An error occurred:', e);
  } finally {
    await browser.close();
  }
}

solveRecaptcha();

让我们运行代码：

Cloudflare Turnstile

在这里，我们将在测试网站 tsmanaged.zlsupport.com 上填写一个小的联系表单，并解决 Cloudflare Turnstile CAPTCHA。与之前的 CAPTCHA 类型一样，我们需要在浏览器的开发者工具中找出 CAPTCHA 的 sitekey。

让我们导入依赖并写入值：

import { launch } from 'puppeteer';
import { CapMonsterCloudClientFactory, ClientOptions, TurnstileProxylessRequest } from '@zennolab_com/capmonstercloud-client';

const CAPMONSTER_API_KEY = 'YOUR_API_KEY';
const WEBSITE_KEY = 'EXAMPLE_SITE_KEY';
const WEBSITE_URL = 'www.example.com';

让我们启动浏览器，为 CapMonster Cloud 创建一个任务，将其发送到服务器，接收并将结果插入到页面中：

async function solveCloudflareTurnstileCaptcha() {
  const browser = await launch({ headless: false });
  const page = await browser.newPage();

  // Initializing the CapMonster client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));

  try {
    await page.goto(WEBSITE_URL);
    console.log('Page is open, solving Cloudflare Turnstile CAPTCHA...');

    await page.type('#username', 'login');
    await page.type('#password', 'pass');

    const turnstileTaskRequest = new TurnstileProxylessRequest({
      websiteURL: WEBSITE_URL,
      websiteKey: WEBSITE_KEY,
    });

    // Getting a captcha solution from CapMonster
    const solutionObject = await cmcClient.Solve(turnstileTaskRequest);
    console.log('CapMonster Solution:', solutionObject);

    const token = solutionObject.solution.token;
    console.log('Captcha solved:', token);

    // Inserting a token into the "token" field
    await page.evaluate((extractedToken) => {
      const tokenField = document.querySelector('#token');
      if (tokenField) {
        tokenField.value = extractedToken;
      }
    }, token);

    console.log('Token inserted into the "token" field!');

    // Click on the "Submit" button after inserting the token
    await page.evaluate(() => {
      const submitButton = document.querySelector('button[type="submit"]');
      if (submitButton) {
        submitButton.click();
      }
    });

    console.log('Clicked on the "Submit" button after token insertion!');

    await new Promise(resolve => setTimeout(resolve, 5000));

  } catch (error) {
    console.error('Error:', error);
  } finally {
    await browser.close();
  }
}

solveCloudflareTurnstileCaptcha();

代码部分解释：

async function solveCloudflareTurnstileCaptcha() { ... }: 声明一个异步函数 `solveCloudflareTurnstileCaptcha`，该函数包含了解决 Cloudflare Turnstile CAPTCHA 的所有代码。

const browser = await launch({ headless: false });: 使用 Puppeteer 启动浏览器。`headless: false` 选项表示浏览器将以图形界面启动。

const page = await browser.newPage();: 在浏览器中创建一个新标签页。

const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));: 使用提供的 API 密钥初始化 CapMonster 客户端。

await page.goto(WEBSITE_URL);: 跳转到包含 Cloudflare Turnstile CAPTCHA 的页面。

console.log('Page opened, solving Cloudflare Turnstile CAPTCHA...');: 在控制台显示消息，表示页面已打开，正在解决 Cloudflare Turnstile CAPTCHA。

await page.type('#username', 'login');: 在“用户名”字段输入数据。

await page.type('#password', 'pass');: 在“密码”字段输入数据。

const turnstileTaskRequest = new TurnstileProxylessRequest({ ... });: 创建一个用于 Turnstile CAPTCHA 解决方案的请求对象。设置如网站 URL 和 Turnstile CAPTCHA 密钥等参数。

const solutionObject = await cmcClient.Solve(turnstileTaskRequest);: 向 CapMonster 发送请求以解决 Turnstile CAPTCHA。结果保存在 `solutionObject` 中。

console.log('CapMonster Solution:', solutionObject);: 在控制台显示来自 CapMonster 的解决方案信息。

const token = solutionObject.solution.token;: 从 `solutionObject` 中提取 token（解决方案结果）。

console.log('Captcha solved:', token);: 在控制台显示消息，表示 CAPTCHA 已解决，并显示 token。

await page.evaluate((extractedToken) => { ... }, token);: 使用 Puppeteer 的 `evaluate` 方法将 token 插入到网页中的“token”字段。

console.log('Token inserted into the "token" field!');: 在控制台显示消息，表示 token 已插入到“token”字段。

await page.evaluate(() => { ... });: 在插入 token 后，点击“提交”按钮，使用 Puppeteer 的 `evaluate` 方法。

console.log('Clicked on the "Submit" button after token insertion!');: 在控制台输出消息，表示在插入 token 后执行了点击“提交”按钮操作。

await new Promise(resolve => setTimeout(resolve, 5000));: 使用 Promise 暂停 5 秒钟。

} catch (error) { console.error('Error:', error); } finally { await browser.close(); }: 处理错误（如果有的话），并在控制台输出错误消息。在 `finally` 块中关闭浏览器，确保完成操作。

solveCloudflareTurnstileCaptcha();: 调用 `solveCloudflareTurnstileCaptcha` 函数，完成整个解决 Cloudflare Turnstile CAPTCHA 的过程。

完整代码：

import { launch } from 'puppeteer';
import { CapMonsterCloudClientFactory, ClientOptions, TurnstileProxylessRequest } from '@zennolab_com/capmonstercloud-client';

const CAPMONSTER_API_KEY = 'YOUR_API_KEY';
const WEBSITE_KEY = 'EXAMPLE_SITE_KEY';
const WEBSITE_URL = 'www.example.com';

async function solveCloudflareTurnstileCaptcha() {
  const browser = await launch({ headless: false });
  const page = await browser.newPage();

  // Initializing the CapMonster client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({ clientKey: CAPMONSTER_API_KEY }));

  try {
    await page.goto(WEBSITE_URL);
    console.log('Page opened, solving Cloudflare Turnstile CAPTCHA...');

    await page.type('#username', 'login');
    await page.type('#password', 'pass');

    const turnstileTaskRequest = new TurnstileProxylessRequest({
      websiteURL: WEBSITE_URL,
      websiteKey: WEBSITE_KEY,
    });

    // Getting a captcha solution from CapMonster
    const solutionObject = await cmcClient.Solve(turnstileTaskRequest);
    console.log('CapMonster Solution:', solutionObject);

    const token = solutionObject.solution.token;
    console.log('Captcha solved:', token);

    // Inserting a token into the "token" field
    await page.evaluate((extractedToken) => {
      const tokenField = document.querySelector('#token');
      if (tokenField) {
        tokenField.value = extractedToken;
      }
    }, token);

    console.log('Token inserted into the "token" field!');

    // Click on the "Submit" button after inserting the token
    await page.evaluate(() => {
      const submitButton = document.querySelector('button[type="submit"]');
      if (submitButton) {
        submitButton.click();
      }
    });

    console.log('Clicked on the "Submit" button after token insertion!');

    await new Promise(resolve => setTimeout(resolve, 5000));

  } catch (error) {
    console.error('Error:', error);
  } finally {
    await browser.close();
  }
}

solveCloudflareTurnstileCaptcha();

让我们运行代码。如果一切正确，代码将解决 CAPTCHA 并打开确认页面：

ReCaptcha v.2

导入所有必要的依赖项并写下数据（您可以为数据创建一个单独的 .env 文件）：

import asyncio
from playwright.async_api import async_playwright
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import RecaptchaV2ProxylessRequest

API_KEY = "YOUR_API_KEY"
WEBSITE_URL = "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high"
WEBSITE_KEY = "EXAMPLE_SITE_KEY"

创建一个任务，将其发送到服务器，使用可用的数据，我们将获取答案并将解决方案插入到 CAPTCHA 表单中：

client_options = ClientOptions(api_key=API_KEY)
cap_monster_client = CapMonsterClient(options=client_options)

async def solve_captcha():
    # Creating a reCAPTCHA solution request type V2 Proxyless
    recaptcha_request = RecaptchaV2ProxylessRequest(websiteUrl=WEBSITE_URL, websiteKey=WEBSITE_KEY)
    return await cap_monster_client.solve_captcha(recaptcha_request)

async def main():
    try:
        async with async_playwright() as p:
            # Launching the browser
            browser = await p.chromium.launch(headless=False)
            context = await browser.new_context()
            page = await context.new_page()

            # Opening a website
            await page.goto(WEBSITE_URL)
            print('Page is open, waiting for reCAPTCHA to load...')

            # Wait a while for the CAPTCHA to load (you can configure the duration)
            await asyncio.sleep(5)

            # reCAPTCHA solution using CapMonster
            responses = await solve_captcha()
            print('Ответ от CapMonster:', responses)

            # Inserting a solved reCAPTCHA into a page
            await page.evaluate(f'document.getElementById("g-recaptcha-response").innerHTML = "{responses["gRecaptchaResponse"]}";')
            print('The result is inserted into the page!')

            # Performing additional actions if necessary (for example, submitting a form)
            await page.click('#recaptcha-demo-submit')
            print('Form is submitted!')

            # Wait a while to observe changes
            await asyncio.sleep(10)

    except Exception as e:
        print('Error:', e)
    finally:
        # Closing the browser
        await browser.close()

asyncio.run(main())

这部分代码的解释：

client_options = ClientOptions(api_key=API_KEY)：使用提供的 API 密钥初始化 CapMonster 客户端设置。

cap_monster_client = CapMonsterClient(options=client_options)：使用在 client_options 中定义的选项创建 CapMonster 客户端。

async def solve_captcha(): ...：异步函数 solve_captcha，它创建一个 reCAPTCHA V2 Proxyless 类型的 CAPTCHA 解决请求，并将其传递给 CapMonster 客户端进行解决。

async def main(): ...：异步 main 函数，包含主要代码，用于打开浏览器，加载页面，使用 CapMonster 解决 CAPTCHA，将解决方案插入页面并执行其他操作。

async with async_playwright() as p: ...：使用 async_playwright 异步控制浏览器。

browser = await p.chromium.launch(headless=False)：启动 Chromium 浏览器，并能够显示图形界面（不是无头模式）。

await page.goto(WEBSITE_URL)：访问指定网站。

await asyncio.sleep(5)：暂停等待 CAPTCHA 加载（在此例中为 5 秒）。

responses = await solve_captcha()：调用 solve_captcha 函数，使用 CapMonster 解决 reCAPTCHA。

await page.evaluate(f'document.getElementById("g-recaptcha-response").innerHTML = "{responses["gRecaptchaResponse"]}";')：使用 Playwright 的 evaluate 方法将 reCAPTCHA 解决方案插入页面。

await page.click('#recaptcha-demo-submit')：点击指定选择器的按钮（在此例中为 reCAPTCHA 演示页面上的 "提交" 按钮）。

await asyncio.sleep(10)：暂停以观察提交表单后的变化（在此例中为 10 秒）。

await browser.close()：在 finally 块中关闭浏览器以完成操作。

asyncio.run(main())：运行异步的 main 函数。

完整代码：

import asyncio
from playwright.async_api import async_playwright
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import RecaptchaV2ProxylessRequest

API_KEY = "YOUR_API_KEY"
WEBSITE_URL = "https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high"
WEBSITE_KEY = "EXAMPLE_SITE_KEY"

client_options = ClientOptions(api_key=API_KEY)
cap_monster_client = CapMonsterClient(options=client_options)

async def solve_captcha():
    # Creating a reCAPTCHA solution request type V2 Proxyless
    recaptcha_request = RecaptchaV2ProxylessRequest(websiteUrl=WEBSITE_URL, websiteKey=WEBSITE_KEY)
    return await cap_monster_client.solve_captcha(recaptcha_request)

async def main():
    try:
        async with async_playwright() as p:
            # Launching the browser
            browser = await p.chromium.launch(headless=False)
            context = await browser.new_context()
            page = await context.new_page()

            # Opening a website
            await page.goto(WEBSITE_URL)
            print('Page is open, waiting for reCAPTCHA to load...')

            # Wait a while for the CAPTCHA to load (you can configure the duration)
            await asyncio.sleep(5)

            # reCAPTCHA solution using CapMonster
            responses = await solve_captcha()
            print('CapMonster response:', responses)

            # Inserting a solved reCAPTCHA into a page
            await page.evaluate(f'document.getElementById("g-recaptcha-response").innerHTML = "{responses["gRecaptchaResponse"]}";')
            print('The result is inserted into the page!')

            # Perform additional actions if necessary (for example, submitting a form)
            await page.click('#recaptcha-demo-submit')
            print('Form is submitted!')

            # Wait a while to observe changes
            await asyncio.sleep(10)

    except Exception as e:
        print('Error:', e)
    finally:
        # Closing the browser
        await browser.close()

asyncio.run(main())

成功的 CAPTCHA 解决方案：

ReCaptcha v.3

导入所有必要的依赖项并输入数据：

import asyncio
from playwright.async_api import async_playwright
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import RecaptchaV3ProxylessRequest

CAPMONSTER_API_KEY = 'YOUR_API_KEY'
WEBSITE_KEY = 'EXAMPLE_SITE_KEY'
WEBSITE_URL = 'https://lessons.zennolab.com/captchas/recaptcha/v3.php?level=beta'

创建一个任务，将其发送到服务器并获取解决方案：

async def solve_recaptcha():
    # Initializing Playwright
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        page = await context.new_page()
        print('Browser initialized!')

        # Initializing the CapMonster client
        client_options = ClientOptions(api_key=CAPMONSTER_API_KEY)
        cap_monster_client = CapMonsterClient(options=client_options)

        try:
            # Setting a custom userAgent
(optional)
            user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36' #Insert yours

            await page.set_extra_http_headers({'User-Agent': user_agent})

            # Going to the specified page
            await page.goto(WEBSITE_URL, wait_until='domcontentloaded')
            print('Browser switched to page with captcha!')

            # Creating a request for a reCAPTCHA solving type V3 Proxyless
            recaptcha_request = RecaptchaV3ProxylessRequest(
                websiteUrl=WEBSITE_URL,
                websiteKey=WEBSITE_KEY,
                action='verify',
                min_score=0.7,
            )

            # reCAPTCHA solving using CapMonster
            task_result = await cap_monster_client.solve_captcha(recaptcha_request)
            print('reCAPTCHA V3 solved:', task_result)

            # Inserting the result into the page
            await page.evaluate(f'document.querySelector(\'#g-recaptcha-response-100000\').style.display = "block";')
            await page.evaluate(f'document.querySelector(\'#g-recaptcha-response-100000\').style.visibility = "visible";')
            await page.evaluate(f'document.querySelector(\'#g-recaptcha-response-100000\').value = "{task_result}";')
            print('The result is inserted into the page!')

            # Click on the button to check
            await page.click('#v3_submit')
            print('"Check" button pressed!')

            # Pause for 10 seconds
            await page.wait_for_timeout(10000)

        finally:
            # Closing the browser
            await browser.close()

# Running an asynchronous function to solve reCAPTCHA
asyncio.run(solve_recaptcha())

这部分代码的解释：

async with async_playwright() as p: ...：使用 async_playwright 异步控制浏览器。

browser = await p.chromium.launch(headless=False)：启动 Chromium 浏览器，能够显示图形界面（而非无头模式）。

await page.goto(URL)：访问指定的网页。

client_options = ClientOptions(api_key=API_KEY)：使用提供的 API 密钥初始化 CapMonster 客户端设置。

cap_monster_client = CapMonsterClient(options=client_options)：使用 client_options 中定义的选项创建 CapMonster 客户端。

recaptcha_request = RecaptchaV3ProxylessRequest(...：创建 reCAPTCHA V3 Proxyless 解决方案的请求对象。此处设置了诸如网站 URL、reCAPTCHA 密钥、动作和最小分数等参数。

task_result = await cap_monster_client.solve_captcha(recaptcha_request)：使用 CapMonster 解决 reCAPTCHA，结果保存在 task_result 中。

await page.evaluate(f'document.querySelector('#g-recaptcha-response-100000').style.display = "block";')：使用 Playwright 的 evaluate 方法将结果插入页面。在此情况下，通过更改元素的样式使其变为可见。

await page.click('[data-action="demo_action"]')：点击指定选择器的按钮（在此例中为“检查”按钮）。

await asyncio.sleep(10)：暂停 10 秒以观察变化。

await browser.close()：在 finally 块中关闭浏览器以完成操作。

asyncio.run(solve_recaptcha())：运行异步的 solve_recaptcha 函数。

完整代码：

import asyncio
from playwright.async_api import async_playwright
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import RecaptchaV3ProxylessRequest

CAPMONSTER_API_KEY = 'YOUR_API_KEY'
WEBSITE_KEY = 'EXAMPLE_SITE_KEY'
WEBSITE_URL = 'https://lessons.zennolab.com/captchas/recaptcha/v3.php?level=beta'

async def solve_recaptcha():
    # Initializing Playwright
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        page = await context.new_page()
        print('Browser initialized!')

        # Initializing the CapMonster client
        client_options = ClientOptions(api_key=CAPMONSTER_API_KEY)
        cap_monster_client = CapMonsterClient(options=client_options)

        try:
            # Installing the user agent
            user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36'
            await page.set_extra_http_headers({'User-Agent': user_agent})

            # Going to the specified page
            await page.goto(WEBSITE_URL, wait_until='domcontentloaded')
            print('Browser switched to page with captcha!')

            # Creating a request for a reCAPTCHA solution type V3 Proxyless
            recaptcha_request = RecaptchaV3ProxylessRequest(
                websiteUrl=WEBSITE_URL,
                websiteKey=WEBSITE_KEY,
                action='verify',
                min_score=0.7,
            )

            # reCAPTCHA solution using CapMonster
            task_result = await cap_monster_client.solve_captcha(recaptcha_request)
            print('reCAPTCHA V3 solved:', task_result)

            # Inserting the result into the page
            await page.evaluate(f'document.querySelector(\'#g-recaptcha-response-100000\').style.display = "block";')
            await page.evaluate(f'document.querySelector(\'#g-recaptcha-response-100000\').style.visibility = "visible";')
            await page.evaluate(f'document.querySelector(\'#g-recaptcha-response-100000\').value = "{task_result}";')
            print('The result is inserted into the page!')

            # Click on the button to check
            await page.click('#v3_submit')
            print('"Check" button pressed!')

            # Pause for 10 seconds
            await page.wait_for_timeout(10000)

        finally:
            # Closing the browser
            await browser.close()

# Running an asynchronous function to solve reCAPTCHA
asyncio.run(solve_recaptcha())

如果一切正确完成，代码将自动解决 CAPTCHA 并打开一个验证成功的页面：

Cloudflare Turnstile

导入所需的依赖：

import asyncio
from playwright.async_api import async_playwright
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import TurnstileProxylessRequest

输入数据（或从 .env 文件中导入）：

API_KEY = 'YOUR_API_KEY'
WEBSITE_KEY = 'EXAMPLE_SITE_KEY'
WEBSITE_URL = 'www.example.com'

创建任务，将其发送到 CapMonster Cloud 服务器以解决 CAPTCHA，获取结果并将令牌插入到相应的 CAPTCHA 元素中：

async def solve_turnstile_captcha():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        page = await context.new_page()

        try:
            await page.goto(WEBSITE_URL)
            print('Page opened, solving Cloudflare Turnstile CAPTCHA...')

            # Fill in the "username" and "password" fields with your credentials
            await page.fill('input[name="username"]', 'yourlogin')
            await page.fill('input[name="password"]', 'yourpass')

            # Initializing the CapMonster client
            client_options = ClientOptions(api_key=API_KEY)
            cap_monster_client = CapMonsterClient(options=client_options)

            turnstile_request = TurnstileProxylessRequest(
                websiteURL=WEBSITE_URL,
                websiteKey=WEBSITE_KEY,
            )

            # Cloudflare Turnstile CAPTCHA Solution Using CapMonster
            task_result = await cap_monster_client.solve_captcha(turnstile_request)
            token = task_result.get('token')
            print('Captcha solved:', token)

            # Inserting a token into the "token" field
            await page.evaluate(f'document.querySelector(\'#token\').value = \'{token}\';')
            print('Token inserted into the "token" field!')

            # Clicking the "Submit" button after inserting the token
            await page.click('button[type="submit"]')
            print('Clicked on the "Submit" button after token insertion!')

            await asyncio.sleep(5)

        except Exception as e:
            print(f"An error occurred: {e}")
        finally:
            await browser.close()

asyncio.run(solve_turnstile_captcha())

解释代码的这一部分：

async with async_playwright() as p: ...：使用async_playwright异步控制浏览器。

browser = await p.chromium.launch(headless=False)：启动Chromium浏览器并启用图形界面（不是无头模式）。

context = await browser.new_context()：为页面创建一个新的上下文。

page = await context.new_page()：在新的上下文中创建一个新页面。

await page.goto(WEBSITE_URL)：访问指定的网址。

await page.fill('input[name="username"]', 'yourlogin')：填写“用户名”字段，使用指定的登录名。

await page.fill('input[name="password"]', 'yourpass')：填写“密码”字段，使用指定的密码。

client_options = ClientOptions(api_key=API_KEY)：使用提供的API密钥初始化CapMonster客户端设置。

cap_monster_client = CapMonsterClient(options=client_options)：使用在client_options中定义的选项创建CapMonster客户端。

turnstile_request = TurnstileProxylessRequest(...)：创建一个请求对象，用于解决Cloudflare Turnstile CAPTCHA Proxyless问题。这里设置了诸如网站URL和密钥等参数。

task_result = await cap_monster_client.solve_captcha(turnstile_request)：使用CapMonster解决Cloudflare Turnstile CAPTCHA。结果保存在task_result中。

token = task_result.get('token')：从解决结果中提取token。

await page.evaluate(f'document.querySelector('#token').value = '{token}';')：使用Playwright的evaluate方法将token插入到“token”字段中。

await page.click('button[type="submit"]')：点击指定选择器的按钮（在此情况下为“提交”按钮）。

await asyncio.sleep(5)：暂停5秒钟，观察更改。

await browser.close()：在finally块中关闭浏览器，确保任务完成。

asyncio.run(solve_cloudflare_turnstile_captcha())：运行异步函数solve_cloudflare_turnstile_captcha。

完整代码：

import asyncio
from playwright.async_api import async_playwright
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import TurnstileProxylessRequest

API_KEY = 'YOUR_API_KEY'
WEBSITE_KEY = 'EXAMPLE_SITE_KEY'
WEBSITE_URL = 'www.example.com'

async def solve_turnstile_captcha():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        page = await context.new_page()

        try:
            await page.goto(WEBSITE_URL)
            print('Page opened, solving Cloudflare Turnstile CAPTCHA...')

            # Fill in the "username" and "password" fields with your data
            await page.fill('input[name="username"]', 'yourlogin')
            await page.fill('input[name="password"]', 'yourpass')

            # Initializing the CapMonster client
            client_options = ClientOptions(api_key=API_KEY)
            cap_monster_client = CapMonsterClient(options=client_options)

            turnstile_request = TurnstileProxylessRequest(
                websiteURL=WEBSITE_URL,
                websiteKey=WEBSITE_KEY,
            )

            # Cloudflare Turnstile CAPTCHA solution using CapMonster
            task_result = await cap_monster_client.solve_captcha(turnstile_request)
            token = task_result.get('token')
            print('Captcha solved:', token)

            # Inserting a token into the "token" field
            await page.evaluate(f'document.querySelector(\'#token\').value = \'{token}\';')
            print('Token inserted into the "token" field!')

            # Clicking the "Submit" button after inserting the token
            await page.click('button[type="submit"]')
            print('Clicked on the "Submit" button after token insertion!')

            await asyncio.sleep(5)

        except Exception as e:
            print(f"An error occurred: {e}")
        finally:
            await browser.close()

asyncio.run(solve_turnstile_captcha())

运行项目并查看结果。如果一切正确，您将看到带有完成验证的页面：

使用 Puppeteer 和 Playwright 结合 CapMonster Cloud 解决复杂 CAPTCHA

✅ 请求已发送

请求加入

CAPTCHA：在线安全的意义

BLS 验证码解决功能已添加到 CapMonster Cloud 扩展中

Puppeteer

ReCaptcha v.2

ReCaptcha v.3

Playwright

ReCaptcha v.2

ReCaptcha v.3

结论

如何识别不同类型的验证码

无法通过LinkedIn上的验证码：原因及最佳解决方案