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

Puppeteer
Playwright
结论

Puppeteer 和 Playwright 是用于自动化浏览器操作的库。借助它们，你可以控制浏览器并执行各种任务，例如打开和导航页面、填写表单、点击按钮、提取数据等。如果结合 CapMonster Cloud 服务，还可以自动解决网站上的 CAPTCHA。接下来，我们将探讨它们的集成，并提供可用于自动绕过 CAPTCHA 的示例代码。

Puppeteer 和 Playwright 之间的区别不大。Puppeteer 由 Google 团队开发，是一个基于 Node.js 的 JavaScript 库。它自带基于 Chromium 引擎的浏览器，无需像 Selenium 那样手动安装 WebDriver。Playwright 由 Microsoft 开发，比 Puppeteer 更加灵活，功能有所扩展，支持多种语言，包括 JavaScript、TypeScript、Python、C# 等。此外，与 Puppeteer 类似，Playwright 也内置多个浏览器，支持在 Chromium、Firefox 和 WebKit（Safari）中进行测试。接下来，让我们看看如何将 Puppeteer 和 Playwright 与 CapMonster Cloud 结合使用。

立即开始，自动化您的解决方案 reCAPTCHA

立即开始演示

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 并打开确认页面：

Playwright

之前我们在 JavaScript 中使用了 Puppeteer。现在，让我们尝试在 Python 中使用 Playwright。我们将继续在 VS Code 中进行工作，以下是安装 Playwright 的步骤：

安装 Playwright。创建一个新的文件夹来存放项目文件，在 VS Code 中打开该文件夹，然后在终端中运行以下命令： pip install playwright
安装浏览器。安装 Playwright 后，要一次性安装所有支持的浏览器（Chromium、Firefox、WebKit），运行命令： python -m playwright install

如果只安装一个浏览器，例如 Chromium，运行命令： python -m playwright install chromium

安装官方的 CapMonster Cloud 库，运行命令 pip install capmonstercloudclient。

现在，您可以编写代码来自动解决 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())

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

结论

如您所见，绕过验证码看起来只是一个困难的任务。您所需要做的就是了解站点数据和验证码数据，指明其类型，正确地创建任务，发送它并接收/插入令牌到所需的元素中。CapMonster Cloud 将完成其余工作。它几乎可以与任何库和框架一起使用，并且通过代码将此服务与 Puppeteer 或 Playwright 集成，将使您能够快速高效地获得对必要站点上即使是最复杂验证码的解决方案。

注意：请确保您在合法范围内使用该产品，仅用于自动化测试您自己的网站或拥有合法访问权限的网站。

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

Puppeteer

ReCaptcha v.2

ReCaptcha v.3

Playwright

ReCaptcha v.2

ReCaptcha v.3

结论

从用户的 CAPTCHA 绕过支出中赚取高达 30% 的分成。

✅ 请求已发送

请求加入