在使用 Scrapling 和 CapSolver 进行网页爬取时如何解决验证码

web scraping

在使用 Scrapling 和 CapSolver 进行网页爬取时如何解决验证码

如何使用 Scrapling 和 CapSolver 解决验证码

Ethan Collins

Pattern Recognition Specialist

05-Dec-2025

关键要点

Scrapling 是一个功能强大的 Python 网络爬虫库，内置反机器人功能和自适应元素跟踪
CapSolver 提供自动验证码解决功能，支持 ReCaptcha v2、v3 和 Cloudflare Turnstile，解决速度快（1-20 秒）
将 Scrapling 与 CapSolver 结合使用，可创建一个强大的爬虫解决方案，可处理大多数验证码保护的网站
StealthyFetcher 在基础 HTTP 请求不够时提供浏览器级别的反检测功能
所有三种验证码类型都使用相同的 CapSolver 流程：创建任务 → 轮询结果 → 注入令牌
生产代码应包含错误处理、速率限制，并遵守网站的服务条款

简介

网络爬虫已成为数据收集、市场研究和竞争分析的重要工具。然而，随着爬虫技术的演进，网站的防护措施也在不断升级。爬虫者最常见的障碍之一是 验证码 —— 这些设计用来区分人类和机器人的挑战。

如果你曾经尝试爬取一个网站，却被“请验证您是人类”的提示挡住，你一定知道这种挫败感。好消息是，有一种强大的组合可以帮你解决这个问题：Scrapling 用于智能网络爬虫，CapSolver 用于自动解决验证码。

在本指南中，我们将逐步讲解如何集成这些工具，成功爬取验证码保护的网站。无论你面对的是 Google 的 ReCaptcha v2、不可见的 ReCaptcha v3，还是 Cloudflare 的 Turnstile，我们都会为你提供解决方案。

什么是 Scrapling？

Scrapling 是一个现代的 Python 网络爬虫库，它自称是“第一个能从网站变化中学习并随之进化的自适应爬虫库”。它旨在让数据提取变得简单，同时提供强大的反机器人功能。

主要功能

自适应元素跟踪：即使网站重新设计，Scrapling 也能使用智能相似性算法重新定位内容
多种获取方法：支持 TLS 指纹模拟的 HTTP 请求、浏览器自动化和隐身模式
反机器人绕过：通过修改后的 Firefox 和指纹欺骗，内置支持绕过 Cloudflare 和其他反机器人系统
高性能：文本提取基准测试显示，5000 个嵌套元素仅需约 2ms，比许多替代方案快得多
灵活的选择器：支持 CSS 选择器、XPath、BeautifulSoup 风格的查找操作和基于文本的搜索
异步支持：支持完整的异步/await 并发爬虫操作

安装

对于基本解析功能：

bash 复制代码

pip install scrapling

对于完整功能（包括浏览器自动化）：

bash 复制代码

pip install "scrapling[fetchers]"
scrapling install

对于所有功能（包括 AI 功能）：

bash 复制代码

pip install "scrapling[all]"
scrapling install

基本用法

Scrapling 使用类方法进行 HTTP 请求：

python 复制代码

from scrapling import Fetcher

# GET 请求
response = Fetcher.get("https://example.com")

# POST 请求带数据
response = Fetcher.post("https://example.com/api", data={"key": "value"})

# 访问响应
print(response.status)       # HTTP 状态码
print(response.body)         # 原始字节
print(response.body.decode()) # 解码后的文本

什么是 CapSolver？

CapSolver 是一个使用先进 AI 自动解决各种验证码的验证码解决服务。它提供了一个简单的 API，可以无缝集成到任何编程语言或爬虫框架中。

立即提升您的自动化预算！
在充值 CapSolver 账户时使用优惠码 SCRAPLING，可获得每次充值额外 6% 的奖励 —— 专为 Scrapling 集成用户设计。
现在在您的 CapSolver 仪表板中领取

支持的验证码类型

ReCaptcha v2（复选框和不可见式）
ReCaptcha v3（基于分数的）
ReCaptcha 企业版（v2 和 v3）
Cloudflare Turnstile
AWS WAF 验证码
以及更多...

获取 API 密钥

在 CapSolver 注册
导航到您的仪表板
从账户设置中复制您的 API 密钥
为账户充值（按次计费）

API 端点

CapSolver 使用两个主要端点：

创建任务：POST https://api.capsolver.com/createTask
获取结果：POST https://api.capsolver.com/getTaskResult

设置 CapSolver 辅助函数

在深入探讨特定验证码类型之前，让我们创建一个可重用的辅助函数来处理 CapSolver API 的工作流程：

python 复制代码

import requests
import time

CAPSOLVER_API_KEY = "YOUR_API_KEY"

def solve_captcha(task_type, website_url, website_key, **kwargs):
    """
    使用 CapSolver API 的通用验证码解决函数。

    参数:
        task_type: 验证码任务类型（例如 "ReCaptchaV2TaskProxyLess"）
        website_url: 包含验证码的页面 URL
        website_key: 验证码的站点密钥
        **kwargs: 验证码类型特定的附加参数

    返回:
        dict: 包含令牌和其他数据的解决方案
    """
    payload = {
        "clientKey": CAPSOLVER_API_KEY,
        "task": {
            "type": task_type,
            "websiteURL": website_url,
            "websiteKey": website_key,
            **kwargs
        }
    }

    # 创建任务
    response = requests.post(
        "https://api.capsolver.com/createTask",
        json=payload
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"任务创建失败: {result.get('errorDescription')}")

    task_id = result.get("taskId")
    print(f"任务已创建: {task_id}")

    # 轮询结果
    max_attempts = 60  # 最多轮询 2 分钟
    for attempt in range(max_attempts):
        time.sleep(2)

        response = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        )
        result = response.json()

        if result.get("status") == "ready":
            print(f"验证码已解决，耗时 {(attempt + 1) * 2} 秒")
            return result.get("solution")

        if result.get("errorId") != 0:
            raise Exception(f"错误: {result.get('errorDescription')}")

        print(f"等待中...（尝试 {attempt + 1}）")

    raise Exception("超时：验证码解决耗时过长")

此函数处理完整的流程：创建任务、轮询结果并返回解决方案。我们将在本指南的其余部分使用它。

使用 Scrapling + CapSolver 解决 ReCaptcha v2

ReCaptcha v2 是经典的“我不是机器人”复选框验证码。触发时，它可能会要求用户识别图像中的对象（如交通灯、人行横道等）。对于爬虫，我们需要以编程方式解决它。

ReCaptcha v2 的工作原理

网站加载带有唯一 站点密钥 的 ReCaptcha 脚本
提交时，脚本生成一个 g-recaptcha-response 令牌
网站将此令牌发送到 Google 进行验证
Google 确认验证码是否被正确解决

查找站点密钥

站点密钥通常在页面 HTML 中找到：

html 复制代码

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

或在脚本标签中：

html 复制代码

<script src="https://www.google.com/recaptcha/api.js?render=6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"></script>

实现

python 复制代码

from scrapling import Fetcher

def scrape_with_recaptcha_v2(target_url, site_key, form_url=None):
    """
    爬取受 ReCaptcha v2 保护的页面。

    参数:
        target_url: 包含验证码的页面 URL
        site_key: ReCaptcha 站点密钥
        form_url: 提交表单的 URL（默认为 target_url）

    返回:
        受保护页面的响应
    """
    # 使用 CapSolver 解决验证码
    print("正在解决 ReCaptcha v2...")
    solution = solve_captcha(
        task_type="ReCaptchaV2TaskProxyLess",
        website_url=target_url,
        website_key=site_key
    )

    captcha_token = solution["gRecaptchaResponse"]
    print(f"获取到令牌: {captcha_token[:50]}...")

    # 使用 Scrapling 提交表单并注入验证码令牌
    # 注意：使用 Fetcher.post() 作为类方法（不是实例方法）
    submit_url = form_url or target_url
    response = Fetcher.post(
        submit_url,
        data={
            "g-recaptcha-response": captcha_token,
            # 添加网站所需的任何其他表单字段
        }
    )

    return response

# 示例用法
if __name__ == "__main__":
    url = "https://example.com/protected-page"
    site_key = "6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"

    result = scrape_with_recaptcha_v2(url, site_key)
    print(f"状态: {result.status}")
    print(f"内容长度: {len(result.body)}")  # 使用 .body 获取原始字节

ReCaptcha v2 不可见版

对于不可见的 ReCaptcha v2（无复选框，表单提交时触发），添加 isInvisible 参数：

python 复制代码

solution = solve_captcha(
    task_type="ReCaptchaV2TaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    isInvisible=True
)

企业版

对于 ReCaptcha v2 企业版，使用不同的任务类型：

python 复制代码

solution = solve_captcha(
    task_type="ReCaptchaV2EnterpriseTaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    enterprisePayload={
        "s": "如需可选的 payload_s 值"
    }
)

使用 Scrapling + CapSolver 解决 ReCaptcha v3

ReCaptcha v3 与 v2 不同 —— 它在后台运行，并根据用户行为分配一个分数（0.0 到 1.0）。接近 1.0 的分数表示更可能是人类行为。

与 v2 的关键区别

方面	ReCaptcha v2	ReCaptcha v3
用户交互	复选框/图像挑战	无（不可见）
输出	通过/失败	分数（0.0-1.0）
动作参数	不需要	需要
使用时机	表单、登录	所有页面加载

查找动作参数

动作参数在网站的 JavaScript 中指定：

javascript 复制代码

grecaptcha.execute('6LcxxxxxxxxxxxxxxxxABCD', {action: 'submit'})

常见动作包括：submit、login、register、homepage、contact。

实现

python 复制代码

from scrapling import Fetcher

def scrape_with_recaptcha_v3(target_url, site_key, page_action="submit", min_score=0.7):
    """
    爬取受 ReCaptcha v3 保护的页面。

    参数:
        target_url: 包含验证码的页面 URL
        site_key: ReCaptcha 站点密钥
        page_action: 动作参数（在 grecaptcha.execute 中找到）
        min_score: 请求的最低分数（0.1-0.9）

    返回:
        受保护页面的响应
    """
    print(f"正在解决 ReCaptcha v3（动作: {page_action}）...")

    solution = solve_captcha(
        task_type="ReCaptchaV3TaskProxyLess",
        website_url=target_url,
        website_key=site_key,
        pageAction=page_action
    )

    captcha_token = solution["gRecaptchaResponse"]
    print(f"获取到令牌，分数为: {solution.get('score', 'N/A')}")

    # 使用 Scrapling 类方法提交请求并注入令牌
    response = Fetcher.post(
        target_url,
        data={
            "g-recaptcha-response": captcha_token,
        },
        headers={
            "User-Agent": solution.get("userAgent", "Mozilla/5.0")
        }
    )

    return response

# 示例用法
if __name__ == "__main__":
    url = "https://example.com/api/data"
    site_key = "6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"

    result = scrape_with_recaptcha_v3(url, site_key, page_action="getData")
    print(f"响应: {result.body.decode()[:200]}")  # 使用 .body 获取内容

ReCaptcha v3 企业版

python 复制代码

solution = solve_captcha(
    task_type="ReCaptchaV3EnterpriseTaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    pageAction=page_action,
    enterprisePayload={
        "s": "可选的 s 参数"
    }
)

使用 Scrapling + CapSolver 解决 Cloudflare Turnstile

Cloudflare Turnstile 是一种新型验证码替代方案，旨在作为传统验证码的“用户友好、隐私保护”替代方案。越来越多使用 Cloudflare 的网站开始采用它。

了解 Turnstile

Turnstile 有三种模式：

托管模式：仅在需要时显示小部件
非交互模式：无需用户交互即可运行
不可见模式：对用户完全不可见

好消息是？CapSolver 可以自动处理所有三种模式。

查找站点密钥

在页面 HTML 中查找 Turnstile：

html 复制代码

<div class="cf-turnstile" data-sitekey="0x4xxxxxxxxxxxxxxxxxxxxxxxxxx"></div>

或在 JavaScript 中：

javascript 复制代码

turnstile.render('#container', {
    sitekey: '0x4xxxxxxxxxxxxxxxxxxxxxxxxxx',
    callback: function(token) { ... }
});

实现

python 复制代码

from scrapling import Fetcher

def scrape_with_turnstile(target_url, site_key, action=None, cdata=None):
    """
    爬取受 Cloudflare Turnstile 保护的页面。

    参数:
        target_url: 包含验证码的页面 URL
        site_key: Turnstile 站点密钥（以 0x4... 开头）
        action: 可选的动作参数
        cdata: 可选的 cdata 参数

    返回:
        受保护页面的响应
    """
    print("正在解决 Cloudflare Turnstile...")

    # 如果提供，构建元数据
    metadata = {}
    if action:
        metadata["action"] = action
    if cdata:
        metadata["cdata"] = cdata

    task_params = {
        "task_type": "AntiTurnstileTaskProxyLess",
        "website_url": target_url,
        "website_key": site_key,
    }

    if metadata:
        task_params["metadata"] = metadata

    solution = solve_captcha(**task_params)

    turnstile_token = solution["token"]
    user_agent = solution.get("userAgent", "")

    print(f"获取到 Turnstile 令牌: {turnstile_token[:50]}...")

    # 使用 Scrapling 类方法提交并注入令牌
    headers = {}
    if user_agent:
        headers["User-Agent"] = user_agent

    response = Fetcher.post(
        target_url,
        data={
            "cf-turnstile-response": turnstile_token,
        },
headers=headers
    )

    return response

# 示例用法
if __name__ == "__main__":
    url = "https://example.com/protected"
    site_key = "0x4AAAAAAAxxxxxxxxxxxxxx"

    result = scrape_with_turnstile(url, site_key)
    print(f"成功！获取到 {len(result.body)} 字节")  # 使用 .body 获取内容

带有 Action 和 CData 的 Turnstile

一些实现需要额外参数：

python 复制代码

solution = solve_captcha(
    task_type="AntiTurnstileTaskProxyLess",
    website_url=target_url,
    website_key=site_key,
    metadata={
        "action": "login",
        "cdata": "session_id_or_custom_data"
    }
)

使用 StealthyFetcher 进行增强的反机器人保护

有时基本的 HTTP 请求是不够的。网站可能使用复杂的机器人检测机制，检查以下内容：

浏览器指纹
JavaScript 执行
鼠标移动和时间
TLS 指纹
请求头

Scrapling 的 StealthyFetcher 通过使用带有隐身修改的真实浏览器引擎，提供浏览器级别的反检测功能。

什么是 StealthyFetcher？

StealthyFetcher 使用修改后的 Firefox 浏览器，具有：

真实的浏览器指纹
JavaScript 执行能力
自动处理 Cloudflare 挑战
TLS 指纹伪装
Cookie 和会话管理

何时使用 StealthyFetcher

场景	使用 Fetcher	使用 StealthyFetcher
简单的表单和 CAPTCHA	是	否
大量 JavaScript 的页面	否	是
多层反机器人保护	否	是
速度至关重要	是	否
Cloudflare Under Attack 模式	否	是

结合使用 StealthyFetcher 和 CapSolver

以下是结合两者以达到最佳效果的方法：

python 复制代码

from scrapling import StealthyFetcher
import asyncio

async def scrape_with_stealth_and_recaptcha(target_url, site_key, captcha_type="v2"):
    """
    结合 StealthyFetcher 的反机器人功能与 CapSolver 解决 ReCaptcha。

    参数:
        target_url: 要抓取的 URL
        site_key: CAPTCHA 站点密钥
        captcha_type: "v2" 或 "v3"

    返回:
        解决 CAPTCHA 后的页面内容
    """

    # 首先使用 CapSolver 解决 CAPTCHA
    print(f"正在解决 ReCaptcha {captcha_type}...")

    if captcha_type == "v2":
        solution = solve_captcha(
            task_type="ReCaptchaV2TaskProxyLess",
            website_url=target_url,
            website_key=site_key
        )
        token = solution["gRecaptchaResponse"]

    elif captcha_type == "v3":
        solution = solve_captcha(
            task_type="ReCaptchaV3TaskProxyLess",
            website_url=target_url,
            website_key=site_key,
            pageAction="submit"
        )
        token = solution["gRecaptchaResponse"]

    else:
        raise ValueError(f"未知的 CAPTCHA 类型: {captcha_type}")

    print(f"获取到令牌: {token[:50]}...")

    # 使用 StealthyFetcher 进行类似浏览器的行为
    fetcher = StealthyFetcher()

    # 导航到页面
    page = await fetcher.async_fetch(target_url)

    # 使用 JavaScript 注入 ReCaptcha 解决方案
    await page.page.evaluate(f'''() => {{
        // 查找 g-recaptcha-response 字段并设置其值
        let field = document.querySelector('textarea[name="g-recaptcha-response"]');
        if (!field) {{
            field = document.createElement('textarea');
            field.name = "g-recaptcha-response";
            field.style.display = "none";
            document.body.appendChild(field);
        }}
        field.value = "{token}";
    }}''')

    # 查找并点击提交按钮
    submit_button = page.css('button[type="submit"], input[type="submit"]')
    if submit_button:
        await submit_button[0].click()
        # 等待导航完成
        await page.page.wait_for_load_state('networkidle')

    # 获取最终页面内容
    content = await page.page.content()

    return content

# 同步包装器以便更方便使用
def scrape_stealth(target_url, site_key, captcha_type="v2"):
    """同步包装器，用于异步的 Stealth 抓取器。"""
    return asyncio.run(
        scrape_with_stealth_and_recaptcha(target_url, site_key, captcha_type)
    )

# 示例用法
if __name__ == "__main__":
    url = "https://example.com/highly-protected-page"
    site_key = "6LcxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD"

    content = scrape_stealth(url, site_key, captcha_type="v2")
    print(f"获取到 {len(content)} 字节的内容")

完整示例：多页面抓取与会话维护

python 复制代码

from scrapling import StealthyFetcher
import asyncio

class StealthScraper:
    """一个在多个页面间保持会话的抓取器。"""

    def __init__(self, api_key):
        self.api_key = api_key
        self.fetcher = None

    async def __aenter__(self):
        self.fetcher = StealthyFetcher()
        return self

    async def __aexit__(self, *args):
        if self.fetcher:
            await self.fetcher.close()

    async def solve_and_access(self, url, site_key, captcha_type="v2"):
        """解决 ReCaptcha 并访问页面。"""
        global CAPSOLVER_API_KEY
        CAPSOLVER_API_KEY = self.api_key

        # 解决 ReCaptcha
        task_type = f"ReCaptcha{captcha_type.upper()}TaskProxyLess"
        solution = solve_captcha(
            task_type=task_type,
            website_url=url,
            website_key=site_key
        )
        token = solution["gRecaptchaResponse"]

        # 导航并注入令牌
        page = await self.fetcher.async_fetch(url)
        # ... 继续页面交互

        return page

# 使用方式
async def main():
    async with StealthScraper("your_api_key") as scraper:
        page1 = await scraper.solve_and_access(
            "https://example.com/login",
            "site_key_here",
            "v2"
        )
        # 后续请求保持会话
        page2 = await scraper.solve_and_access(
            "https://example.com/dashboard",
            "another_site_key",
            "v3"
        )

asyncio.run(main())

最佳实践与技巧

1. 速率限制

不要对网站进行大量请求。在请求之间实现延迟：

python 复制代码

import time
import random

def polite_scrape(urls, min_delay=2, max_delay=5):
    """使用随机延迟进行抓取，更像人类行为。"""
    results = []
    for url in urls:
        result = scrape_page(url)
        results.append(result)

        # 请求之间的随机延迟
        delay = random.uniform(min_delay, max_delay)
        time.sleep(delay)

    return results

2. 错误处理

始终优雅地处理潜在的失败：

python 复制代码

def robust_solve_captcha(task_type, website_url, website_key, max_retries=3, **kwargs):
    """自动重试的 CAPTCHA 解决方法。"""
    for attempt in range(max_retries):
        try:
            return solve_captcha(task_type, website_url, website_key, **kwargs)
        except Exception as e:
            print(f"第 {attempt + 1} 次尝试失败: {e}")
            if attempt < max_retries - 1:
                time.sleep(5)  # 重试前等待
            else:
                raise

3. 遵守 robots.txt

在抓取前检查网站的 robots.txt：

python 复制代码

from urllib.robotparser import RobotFileParser

def can_scrape(url):
    """检查 robots.txt 是否允许抓取。"""
    rp = RobotFileParser()
    rp.set_url(f"{url}/robots.txt")
    rp.read()
    return rp.can_fetch("*", url)

4. 使用代理进行大规模抓取

在大规模抓取时，轮换代理以避免 IP 被封：

python 复制代码

# CapSolver 支持代理任务
solution = solve_captcha(
    task_type="ReCaptchaV2Task",  # 注意：没有 "ProxyLess"
    website_url=target_url,
    website_key=site_key,
    proxy="http://user:pass@proxy.example.com:8080"
)

5. 在可能时缓存解决方案

CAPTCHA 令牌通常在 1-2 分钟内有效。如果需要进行多次请求，可复用令牌：

python 复制代码

import time

class CaptchaCache:
    def __init__(self, ttl=120):  # 默认 2 分钟 TTL
        self.cache = {}
        self.ttl = ttl

    def get_or_solve(self, key, solve_func):
        """获取缓存的令牌或解决新的。"""
        if key in self.cache:
            token, timestamp = self.cache[key]
            if time.time() - timestamp < self.ttl:
                return token

        token = solve_func()
        self.cache[key] = (token, time.time())
        return token

对比表格

CAPTCHA 类型对比

特性	ReCaptcha v2	ReCaptcha v3	Cloudflare Turnstile
用户交互	复选框 + 可能的挑战	无	最小或无
站点密钥格式	`6L...`	`6L...`	`0x4...`
响应字段	`g-recaptcha-response`	`g-recaptcha-response`	`cf-turnstile-response`
Action 参数	无	是（必需）	可选
解决时间	1-10 秒	1-10 秒	1-20 秒
CapSolver 任务	`ReCaptchaV2TaskProxyLess`	`ReCaptchaV3TaskProxyLess`	`AntiTurnstileTaskProxyLess`

Scrapling Fetcher 对比

特性	Fetcher	StealthyFetcher
速度	非常快	较慢
JavaScript 支持	无	有
浏览器指纹	无	真实的 Firefox
内存使用	低	较高
Cloudflare 绕过	无	有
最佳使用场景	简单请求	复杂反机器人系统

常见问题

Q: CapSolver 的费用是多少？

查看 CapSolver 定价页面以获取当前价格。

Q: 如何在网页上找到站点密钥？

在网页源代码中搜索（Ctrl+U）：

data-sitekey 属性
grecaptcha.execute JavaScript 调用
reCaptcha 脚本 URL 中的 render= 参数
class="cf-turnstile" 用于 Turnstile

Q: 如果 CAPTCHA 令牌在使用前过期怎么办？

令牌通常在 1-2 分钟后过期。请尽可能在表单提交前解决 CAPTCHA。如果出现验证错误，请使用新的令牌重新解决。

Q: 我可以将 CapSolver 与异步代码一起使用吗？

可以！将解决函数包装在异步执行器中：

python 复制代码

import asyncio

async def async_solve_captcha(*args, **kwargs):
    loop = asyncio.get_event_loop()
    return await loop.run_in_executor(
        None,
        lambda: solve_captcha(*args, **kwargs)
    )

Q: 如何处理单个页面上的多个 ReCaptchas？

分别解决每个 CAPTCHA 并在提交时包含所有令牌：

python 复制代码

# 解决多个 ReCaptchas
solution_v2 = solve_captcha("ReCaptchaV2TaskProxyLess", url, key1)
solution_v3 = solve_captcha("ReCaptchaV3TaskProxyLess", url, key2, pageAction="submit")

# 使用 Scrapling 类方法提交令牌
response = Fetcher.post(url, data={
    "g-recaptcha-response": solution_v2["gRecaptchaResponse"],
    "g-recaptcha-response-v3": solution_v3["gRecaptchaResponse"],
})

结论

结合 Scrapling 和 CapSolver 提供了强大的解决方案，用于抓取受 CAPTCHA 保护的网站。以下是快速总结：

使用 Scrapling 的 Fetcher 进行速度重要的简单请求
使用 StealthyFetcher 在面对复杂的反机器人系统时
使用 CapSolver 解决 ReCaptcha v2、v3 和 Cloudflare Turnstile
实施最佳实践，如速率限制、错误处理和代理轮换

请始终负责任地进行抓取：

遵守网站的服务条款
不要对服务器造成过载
以道德方式使用数据
考虑联系网站所有者获取 API 访问权限

准备好开始抓取了吗？在 capsolver.com 获取 CapSolver API 密钥，并通过 pip install "scrapling[all]" 安装 Scrapling。

合规声明：本博客提供的信息仅供参考。CapSolver 致力于遵守所有适用的法律和法规。严禁以非法、欺诈或滥用活动使用 CapSolver 网络，任何此类行为将受到调查。我们的验证码解决方案在确保 100% 合规的同时，帮助解决公共数据爬取过程中的验证码难题。我们鼓励负责任地使用我们的服务。如需更多信息，请访问我们的服务条款和隐私政策。