如何用中间件处理 Scrapy 里的 DataDome 403 拦截

要在 Scrapy 中处理 DataDome,请把工作都放进一个下载器中间件。它会发现 403 拦截页,用 Python SDK 的 datadome 方法向 CapSkip 取得一个 datadome cookie,然后带着这个 cookie、它的 User-Agent 和同一个代理重试。DataDome 的 Scrapy 方案成败取决于优先级数字、去重过滤器、一次阻塞的 SDK 调用,以及每个代理一个 cookie jar。本文把 CapSkip DataDome 识别工具 接入一个 Scrapy 项目,并报告在我的测试里每个选择带来了什么效果。
你需要什么
- 一台装有 CapSkip 3.2.0 或更高版本的 Windows PC,这是第一个支持 DataDome 的版本。请按 设置指南 安装并启动 CapSkip。
- Python 3.11 或更高版本,Scrapy 2.20、w3lib 和 itemadapter 都要求这个版本。
- Scrapy 2.14 或更高版本。在 2.13.4 上,中间件会因 TypeError 而失败,因为那个版本仍然向每个中间件方法传入 "spider"。
- capskip 1.5.0 或更高版本,这是第一个带有 datadome 方法的版本。
- CapSkip 应答的地址:Local mode 下是 127.0.0.1,只有同一台 PC 能访问;Server mode 下是你的网络地址或公网 IP。
- 每个爬取身份配一个粘性代理,写成完整的 URL,例如
http://user:[email protected]:8080。出口 IP 在每次连接时都会变的代理无法产生可用的 cookie,CapSkip 文档里这样说。
在 PowerShell 提示符下,创建下面所有代码块都要放进去的项目。文件名相对于存放 scrapy.cfg的文件夹,以某个文件开头的代码块会替换自动生成的那个文件。
pip install scrapy capskip scrapy startproject shop cd shop
我是对自己写的模拟服务器做的测试,不是真实的 DataDome 站点,也不是 CapSkip 应用。其中一个照搬了 CapSkip API 文档里对 in.php 和 res.php 的检查。另一个对请求一律回复 403,除非请求带着第一个模拟服务器签发的 cookie,并且 User-Agent 和代理与签发时一致;这些绑定规则来自 CapSkip 文档,不是 DataDome。我用的是 Python 3.11.7 和 3.14.0。除非另有说明,计数来自 Scrapy 2.20.0 和 capskip 1.7.0, DOWNLOAD_DELAY 设为 0,模拟服务器 0.4 秒完成识别,两个 Python 版本上的结果一致。Scrapy 2.14.0 搭配 capskip 1.5.0,以及 Scrapy 2.19.0 搭配 capskip 1.6.0,在少数几种情况下给出了相同的计数。
搭建 DataDome Scrapy 中间件
第 1 步:选定优先级数字
Scrapy 会调用 process_request (数字从小到大)和 process_response (数字从大到小),所以数字越大,越靠近下载器。位于 590 的 HttpCompressionMiddleware 负责解压正文,所以我们的数字必须小于 590 才能读到拦截页。位于 550 的 RetryMiddleware 把响应变成重试,所以我们的数字必须更大,才能先看到这些响应。这样就剩下 551 到 589,而 580 属于 MetaRefreshMiddleware,所以设置里用 570。下面的代码块组成一个项目,按顺序粘贴,没有哪一块能单独运行。
# shop/settings.py: add these lines at the end
DOWNLOADER_MIDDLEWARES = {
# process_response runs from high numbers to low, so 570 sees a response
# after HttpCompressionMiddleware (590) and before RetryMiddleware (550).
"shop.middlewares.DataDomeMiddleware": 570,
}
DATADOME_CAPSKIP_HOST = "127.0.0.1" # Server mode: your server's address
DATADOME_CAPSKIP_PORT = 8080
DATADOME_MAX_SOLVES = 3 # per request, and per domain and jar between good pages在 650 时,gzip 压缩的拦截页以 1f 8b 这两个字节的形式到达中间件,403 就这样被放过了;在 570 时它被识别了。当 403 在 RETRY_HTTP_CODES里时,模拟站点在识别之前提供了 3 个拦截页(中间件在 540),而在 570 时只有 1 个。
第 2 步:发现拦截页
DataDome 的拦截以状态码 401 或 403 的形式到来。如果拦截页里已经有挑战的 iframe,代码就按 CapSkip 文档所说,原样使用那个地址。否则它会构建 captcha_url ,数据取自脚本对象 dd,其中 rt 的值决定路径:设备检查用 /interstitial/,滑块用 /captcha/。文档表格只为 /captcha/ 列出了 t 参数,但文档自带的 JavaScript 无条件地设置它,我照 JavaScript 来。任何读不出来的内容都返回 None,所以普通的 403 会原样通过。九个手工构造的响应覆盖了每种情况,一次模拟的设备检查用 1 个任务处理了 2 个页面。这个结构来自 CapSkip 文档,不是真实页面。
# shop/middlewares.py
import asyncio
import html
import json
import logging
import re
from urllib.parse import urlencode
from capskip import ApiException, CapSkip, CapSkipError
from scrapy.http import TextResponse
from scrapy.utils.httpobj import urlparse_cached
log = logging.getLogger(__name__)
DD_OBJECT = re.compile(r"var\s+dd\s*=\s*(\{[^}]*\})")
IFRAME = re.compile(r'src="(https://[^"]*captcha-delivery\.com/(?:captcha|interstitial)/\?[^"]*)"')
def captcha_url_for(response):
"""The challenge address from a DataDome block page, or None."""
if response.status not in (401, 403) or not isinstance(response, TextResponse):
return None
frame = IFRAME.search(response.text)
if frame: # the page already carries the challenge address
return html.unescape(frame.group(1))
found = DD_OBJECT.search(response.text)
if not found:
return None
try:
dd = json.loads(found.group(1).replace("'", '"'))
path = "interstitial" if dd["rt"] == "i" else "captcha"
query = {"initialCid": dd["cid"], "hash": dd["hsh"], "cid": dd["cookie"],
"t": dd.get("t"), "referer": response.url, "s": dd["s"],
"e": dd.get("e"), "b": dd.get("b"), "dm": "cd"}
except (KeyError, ValueError):
return None # a dd object this code does not understand
query = {k: v for k, v in query.items() if v}
host = dd.get("host", "geo.captcha-delivery.com")
return f"https://{host}/{path}/?{urlencode(query)}"第 3 步:每个 cookie jar 一个身份
cookie 存放在由 cookiejar meta 键选定的 jar 里,所以中间件为每个 jar 保存一个身份:cookie、它的 User-Agent、CapSkip 选了代理时的那个代理,以及一个随每次识别递增的代次编号。没有 User-Agent 那一行,重试就会带着 Scrapy 默认的 User-Agent 发出,四个直连的页面以 3 个任务、0 个页面收场。
cookie 通过 "cookies" 参数传入,位于 700 的 CookiesMiddleware 会把它复制进 jar。它只会添加到带着它的某个请求回来为止,所以站点给的替换 cookie 不会被覆盖。模拟服务器会发一个,之后抓取的页面带着它,没有产生新任务。Cookie 请求头不行,因为 CookiesMiddleware 会根据 jar 重建请求头,关掉 cookie 也不行。两种做法都以 3 个任务、0 个页面收场。
"Domain" 和 "Path" 属性来自结果的 "code" 字段,里面是 DataDome 设置时的原样 cookie,所以指定站点的 cookie 会保留它的域名。模拟服务器给 127.0.0.1 上的页面一个 host-only cookie。
# shop/middlewares.py, continued
def cookie_attributes(code):
"""Domain, Path and the rest of a Set-Cookie string, names in lower case."""
pairs = (part.partition("=") for part in code.split(";")[1:])
return {name.strip().lower(): value.strip() for name, _, value in pairs if value}
def cookies_without(cookies, name):
"""A request's cookies as a list, minus any with this name."""
if isinstance(cookies, dict):
cookies = [{"name": k, "value": v} for k, v in cookies.items()]
return [c for c in cookies if c["name"] != name]
class Identity:
"""What every request in one cookie jar has to keep sending."""
def __init__(self):
self.user_agent = None
self.cookie = None # datadome=VALUE
self.attrs = {} # Domain and Path, from the cookie as DataDome set it
self.proxy = None # set only when CapSkip solved through its own list
self.generation = 0 # grows with every solve
self.fresh = False # True until a request has carried the cookie to the jar
class DataDomeMiddleware:
def __init__(self, crawler):
s = crawler.settings
self.stats = crawler.stats
self.max_solves = s.getint("DATADOME_MAX_SOLVES", 3)
self.solver = CapSkip(host=s.get("DATADOME_CAPSKIP_HOST", "127.0.0.1"),
port=s.getint("DATADOME_CAPSKIP_PORT", 8080))
self.identities = {} # cookiejar key -> Identity
self.solving = {} # cookiejar key -> the solve that is running
self.spent = {} # (domain, jar) -> solves since the last page that was not a block
@classmethod
def from_crawler(cls, crawler):
return cls(crawler)
def process_request(self, request):
# HttpProxyMiddleware (750) moves the proxy login into a header, so
# keep the proxy as the spider wrote it, login included.
request.meta.setdefault("dd_proxy", request.meta.get("proxy"))
ident = self.identities.get(request.meta.get("cookiejar"))
request.meta["dd_generation"] = ident.generation if ident else 0
if not ident:
return
# The cookie only works with the User-Agent and address that earned it.
request.headers["User-Agent"] = ident.user_agent
if ident.proxy:
request.meta["proxy"] = ident.proxy
if ident.fresh: # CookiesMiddleware (700) copies this into the jar
name, value = ident.cookie.split("=", 1)
cookie = {"name": name, "value": value,
"path": ident.attrs.get("path", "/")}
if "domain" in ident.attrs:
cookie["domain"] = ident.attrs["domain"]
request.cookies = cookies_without(request.cookies, name) + [cookie]
request.meta["dd_carried"] = ident.generation第 4 步:在线程里识别,然后重试
CapSkip 的 datadome 方法在轮询时会阻塞。直接从协程里调用它会占住 reactor,所以中间件把它交给 asyncio.to_thread。SDK 还提供了 AsyncCapSkip,它的 datadome 方法可以 await。重试的请求会设置 dont_filter,因为它的 URL 已经通过了去重过滤器。没有它,dupefilter 把两次重试都丢掉了,而 dupefilter/filtered 的读数是 2。
# shop/middlewares.py, continued
async def solve(self, key, captcha_url, request):
proxy = request.meta.get("dd_proxy")
arg = None
if proxy: # solve through the proxy the crawl uses
scheme, rest = proxy.split("://", 1)
arg = {"type": scheme.upper(), "uri": rest}
# The SDK blocks, so it runs in a thread and the reactor stays free.
result = await asyncio.to_thread(
self.solver.datadome, captcha_url, request.url, proxy=arg)
ident = self.identities.setdefault(key, Identity())
ident.user_agent = result["userAgent"]
ident.cookie = result["cookie"]
ident.attrs = cookie_attributes(result["code"])
if result.get("proxy"):
ident.proxy = "http://" + result["proxy"]
ident.generation += 1
ident.fresh = True
self.stats.inc_value("datadome/solves")
return ident
def retry(self, request):
meta = {**request.meta, "dd_tries": request.meta.get("dd_tries", 0) + 1}
cookies = cookies_without(request.cookies, "datadome") # process_request adds the current one
# dont_filter: the dupefilter has already seen this URL
return request.replace(cookies=cookies, dont_filter=True, meta=meta)这个扩展每 50 毫秒打一次点,并记录最长的间隔。这次爬取有 1 个被拦截的页面、30 个打开的页面和 8 个同时进行的请求,模拟服务器用了 3 秒,只有识别调用的写法变了。每一行是每个 Python 版本上至少三次运行的范围。
# shop/heartbeat.py (settings.py then needs EXTENSIONS = {"shop.heartbeat.Heartbeat": 500})
import asyncio
import time
from scrapy import signals
class Heartbeat:
"""Ticks every 50 ms and records the longest gap between two ticks."""
@classmethod
def from_crawler(cls, crawler):
ext = cls()
ext.stats = crawler.stats
crawler.signals.connect(ext.start, signals.spider_opened)
crawler.signals.connect(ext.stop, signals.spider_closed)
return ext
def start(self):
self.longest, self.last, self.running = 0.0, time.perf_counter(), True
self.tick()
def tick(self):
if self.running:
now = time.perf_counter()
self.longest = max(self.longest, now - self.last)
self.last = now
asyncio.get_running_loop().call_later(0.05, self.tick)
def stop(self):
self.running = False
self.stats.set_value("heartbeat/longest_gap_ms", round(self.longest * 1000))| solve 调用 SDK 的方式 | 一台 PC 上最长的打点间隔 |
|---|---|
| 在协程里直接调用 | 约 3770 到 3840 ms |
| asyncio.to_thread,即上面的代码 | 约 65 到 75 ms |
| 在协程里 await AsyncCapSkip | 约 220 到 530 ms |
| deferToThread 加 maybe_deferred_to_future | 约 65 到 90 ms |
| deferToThread,不做转换直接 await | 约 65 到 80 ms,请求丢失 |
AsyncCapSkip(我在每个 Python 版本上各跑了六次)能用,但停顿更久:每次调用 CapSkip 都会新建一个 httpx 客户端,在这台 PC 上新建一个要约 130 到 190 ms。最后一行看起来正确,其实不对:它抛出了 RuntimeError,消息是 Task got bad yield,请求丢失。整个中间件还需要 asyncio reactor,这是 Scrapy 2.20.0 的默认值。在经典的 select reactor 下,它抛出了 RuntimeError,没有发出任何任务。
第 5 步:决定每个被拦截的响应做什么
同一个 jar 里的请求会一起被拦截,每一个都会启动一次识别。第一个被拦截的响应启动识别并把它存进 self.solving,同一个 jar 里的其他响应等着它。八个页面经一个代理,用这段代码产生了 1 个任务,而每个响应各自识别时是 8 个。把 CONCURRENT_REQUESTS_PER_DOMAIN 设为 1 并没有减少拦截页:四个不带代理发出的页面,在第一个 cookie 到达之前仍然收到了四个拦截页。
DATADOME_MAX_SOLVES 限制两个计数,两个都需要。一个请求最多可以重试这么多次(dd_tries)。每一对域名与 cookie jar,在两个成功通过的页面之间,最多可以启动这么多次识别(self.spent)。如果只按域名计,五个 jar 各同时取一个页面(每个域名允许 16 个请求),得到 3 个任务、丢了 2 个页面。按域名加 jar 计,它们得到 5 个任务、5 个页面。在 60 个正常页面里,有一个 URL 拒绝所有 cookie,它不断重置预算,只有按请求的计数才拦住了它,停在 3 个任务。因为 CapSkip 是一款 无限量验证码识别工具 ,采用统一授权定价,所以这些上限防的是死循环,而不是你的钱包。
# shop/middlewares.py, continued
async def process_response(self, request, response):
key = request.meta.get("cookiejar")
ident = self.identities.get(key)
if ident and request.meta.get("dd_carried") == ident.generation:
ident.fresh = False # the jar has seen the cookie by now
captcha_url = captcha_url_for(response)
budget = (urlparse_cached(request).hostname, key)
if captcha_url is None:
self.spent.pop(budget, None) # a page got through: reset the budget
return response
if request.meta.get("dd_tries", 0) >= self.max_solves:
return response
if ident and ident.generation > request.meta.get("dd_generation", 0):
return self.retry(request) # sent before the last solve
if self.spent.get(budget, 0) >= self.max_solves:
self.stats.inc_value("datadome/budget_used_up")
return response
task = self.solving.get(key)
if task is None: # the first blocked request starts the solve
self.spent[budget] = self.spent.get(budget, 0) + 1
task = asyncio.ensure_future(self.solve(key, captcha_url, request))
self.solving[key] = task
task.add_done_callback(lambda _: self.solving.pop(key, None))
try:
await task # the others in the same jar wait for it
except ApiException as err:
if "ERROR_PROXY" in str(err): # a retry through that address fails again
log.error("DataDome solve refused for the address: %s", err)
return response
log.warning("DataDome solve refused: %s", err)
return self.retry(request) # fetch the page again: a new challenge
except CapSkipError as err:
log.error("DataDome solve failed: %r", err)
return response
return self.retry(request)第 6 步:每个代理一个 cookie jar
经过多个代理的爬取需要每个代理一个 jar,这样每个身份只有一个地址,spider 会用代理给每个 jar 命名。Scrapy 不会把这两个键带到你根据响应构建的请求上:用 response.follow 跟随的链接,如果没有 meta,就会通过默认 jar 直接发出,被拦截后又识别了一次。请把 proxy 和 cookiejar 这两个键复制到你创建的每个请求里。
两个代理共用一个 jar 是另一个错误:八个页面分到两个代理上,在一次一个请求、延迟 0.2 秒的条件下,每个 Python 版本上的三次运行都以 12 个拦截页收场,而不是总共 8 个。两种布局都用了 2 个任务。
# shop/spiders/shop.py import scrapy # your own sticky proxies, with the login if they need one PROXIES = ["http://user:[email protected]:8080", "http://user:[email protected]:8080"] # your own DataDome-protected pages URLS = [f"https://www.example.com/page/{n}" for n in range(1, 9)] class ShopSpider(scrapy.Spider): name = "shop" async def start(self): for n, url in enumerate(URLS): proxy = PROXIES[n % len(PROXIES)] # one cookie jar per proxy, named after it yield scrapy.Request(url, meta={"proxy": proxy, "cookiejar": proxy}) def parse(self, response): yield {"url": response.url, "status": response.status, "h1": response.css("h1::text").get()}
两个列表里放的都是占位符;我自己跑的时候把它们换成了我的模拟代理和页面,别的什么都没改。按模板里的延迟 1,它用了 2 个任务,加载了全部 8 个页面。Scrapy 会在响应回来之前把代理的登录信息移到请求头里,所以中间件按原样保留代理;没有这一步,我的模拟服务器收到的任务里就没有登录信息。
# run this in the folder that holds scrapy.cfg scrapy crawl shop -O out.jsonl
当 CapSkip 通过它自己的代理列表识别时,结果会指出那个代理,身份会保留它,因为 cookie 只在经过它时才有效。文档说它返回时不带登录信息,所以带登录信息的列表代理没有测试过。
你在 Scrapy 里可能遇到的 DataDome 403 错误
我在对模拟服务器的一次运行里触发了每一行,除了缺少的 dd 对象和只有 iframe 的页面,这两种只由手工构造的响应覆盖。被拒绝的任务会记入日志,页面重新抓取。点名某个地址的拒绝,ERROR_PROXY_BANNED 或 ERROR_PROXY_CONNECT_REFUSED,会记入日志并原样放行,因为文档说通过那个地址重试还会失败。我的模拟服务器在取结果时返回了这两个,我没有在真实应用上触发过它们。其他任何 SDK 错误都会记入日志并原样放行。
| 你所看到的 | 原因 | 修复 |
|---|---|---|
| TypeError,提示意外的关键字参数 "spider" | Scrapy 2.13 或更旧的版本 | 升级到 2.14 或更高版本 |
| RuntimeError: Task got bad yield | 直接在协程里 await 一个 Deferred | 使用 asyncio.to_thread 或 maybe_deferred_to_future |
| 403 页面到达 HttpErrorMiddleware,没有发出任何任务 | 中间件数字高于 590,或者拦截页既没有 iframe 地址,也没有 dd 对象 | 使用 551 到 589,并在拦截页里查找这两者之一 |
| 页面一直被拦截,stats 里出现 budget_used_up 计数 | cookie 被关掉、使用了 Cookie 请求头,或者改了 User-Agent | 把重试和身份对比一下 |
| 日志里出现 ERROR_PROXY_BANNED 或 ERROR_PROXY_CONNECT_REFUSED | CapSkip 指出该地址被封禁或无法连接 | 给那个 jar 换一个代理 |
ValidationException,带有 t=bv 出现在日志里 | 拦截页说该地址被封禁 | 给那个 jar 换一个代理 |
| 日志里出现 NetworkException | settings.py 里的主机和端口没有任何应答 | 启动 CapSkip,并检查这两项 |
排序规则见 Scrapy 项目的 下载器中间件参考文档 。同样的思路用于 reCAPTCHA,请看 Scrapy CAPTCHA 中间件指南,大规模爬取请看 网络爬虫页面.
在服务器上运行 CapSkip
Server mode 会让 CapSkip 在你的网络地址或公网 IP 上应答,所以另一台 PC 上的爬虫或一台 Windows VPS 都能访问它。请在 CapSkip 的 连接设置 中选择它,并把那台机器的地址填进 DATADOME_CAPSKIP_HOST;其他都不用改。启动 Server mode 会让 CapSkip 端口对所有地址开放,所以请添加一条 Windows Firewall 阻止规则,挡住不该访问它的机器。识别在服务器上进行,所以 cookie 是从服务器的地址取得的,除非请求带有代理,中间件会把代理传过去。这些我都没有运行,只有 127.0.0.1 上的模拟服务器,而开启 API Key Validation 的话,你要把 apiKey 传给 CapSkip 构造函数。
常见问题
能不能用 await AsyncCapSkip 代替线程?
可以。用 AsyncCapSkip 代替 CapSkip,并在 self.solve里 await 它的 datadome 方法。它在两个 Python 版本上给出的计数和线程方式一致,只是在我的 PC 上停顿更长,约 220 到 530 ms。
真实的 DataDome Scrapy 爬取需要多少次识别?
我说不准。在模拟服务器里是每个代理一次,因为模拟服务器从不让 cookie 过期。统计键 datadome/solves 会统计你自己爬取里的识别次数。
