DataDome-403-Blockaden in Scrapy mit einer Middleware lösen

datadome scrapy - How to Solve DataDome Scrapy 403 Blocks With a Middleware

Um DataDome in Scrapy zu behandeln, legen Sie die Arbeit in eine einzige Downloader-Middleware. Sie erkennt die 403-Blockseite, holt mit der Methode datadome des Python SDK ein datadome-Cookie von CapSkip und wiederholt die Anfrage mit diesem Cookie, dessen User-Agent und demselben Proxy. Ein DataDome-Scrapy-Setup steht und fällt mit der Prioritätsnummer, dem Duplikatfilter, einem blockierenden SDK-Aufruf und einem Cookie-Jar pro Proxy. Dieser Leitfaden bindet den CapSkip-Solver für DataDome in ein Scrapy-Projekt ein und berichtet, was jede Entscheidung in meinen Läufen bewirkt hat.

Was Sie brauchen

  • Ein Windows-PC mit CapSkip 3.2.0 oder neuer, der ersten Version mit DataDome. Folgen Sie der Einrichtungsanleitung um CapSkip zu installieren und zu starten.
  • Python 3.11 oder neuer, was Scrapy 2.20, w3lib und itemadapter alle voraussetzen.
  • Scrapy 2.14 oder neuer. Unter 2.13.4 scheitert die Middleware mit einem TypeError, weil diese Version noch "spider" an jede Middleware-Methode übergibt.
  • capskip 1.5.0 oder neuer, die erste Version mit der Methode datadome.
  • Die Adresse, auf der CapSkip antwortet: 127.0.0.1 im Local-Modus, die nur denselben PC erreicht, oder Ihre Netzwerkadresse oder öffentliche IP im Server-Modus.
  • Ein Sticky-Proxy pro Crawl-Identität, als vollständige URL wie http://user:[email protected]:8080. Ein Proxy, der bei jeder Verbindung seine Exit-IP wechselt, kann kein funktionierendes Cookie erzeugen, so die CapSkip-Dokumentation.

Erstellen Sie in einer PowerShell-Eingabeaufforderung das Projekt, in das alle folgenden Blöcke gehören. Dateinamen sind relativ zu dem Ordner, der scrapy.cfg enthält, und ein Block, der eine Datei beginnt, ersetzt die generierte.

pip install scrapy capskip
scrapy startproject shop
cd shop

Ich habe gegen Mock-Server getestet, die ich selbst geschrieben habe, nicht gegen eine echte DataDome-Website und nicht gegen die CapSkip-App. Einer kopiert die Prüfungen von in.php und res.php aus der CapSkip-API-Dokumentation. Der andere antwortet mit 403, sofern die Anfrage kein Cookie trägt, das der erste ausgestellt hat, und zwar für den User-Agent und den Proxy, für die es ausgestellt wurde; diese Bindungsregeln stammen aus der CapSkip-Dokumentation, nicht von DataDome. Ich habe Python 3.11.7 und 3.14.0 verwendet. Sofern nichts anderes steht, stammen die Zahlen von Scrapy 2.20.0 und capskip 1.7.0, mit DOWNLOAD_DELAY auf 0 und einem Mock, der in 0,4 Sekunden löst; sie stimmten auf beiden Python-Versionen überein. Scrapy 2.14.0 mit capskip 1.5.0 und Scrapy 2.19.0 mit capskip 1.6.0 ergaben in einigen Fällen dieselben Zahlen.

Die DataDome-Scrapy-Middleware bauen

Schritt 1: Die Prioritätsnummer wählen

Scrapy ruft process_request in aufsteigender Reihenfolge der Nummern auf und process_response in absteigender Reihenfolge auf, daher liegt eine größere Nummer näher am Downloader. HttpCompressionMiddleware bei 590 entpackt den Body, unsere Nummer muss also unter 590 liegen, damit sie die Blockseite lesen kann. RetryMiddleware bei 550 macht aus Responses Retries, unsere muss also höher liegen, um sie zuerst zu sehen. Damit bleiben 551 bis 589, und da 580 zu MetaRefreshMiddleware gehört, verwenden die Einstellungen 570. Die folgenden Blöcke bilden ein Projekt, werden der Reihe nach eingefügt, und keiner läuft allein.

# 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

Bei 650 erreichte eine gzip-komprimierte Blockseite die Middleware als die Bytes 1f 8b, und die 403 ging durch; bei 570 wurde sie gelöst. Mit 403 in RETRY_HTTP_CODES, lieferte die Mock-Website 3 Blockseiten vor der Lösung bei 540 und 1 bei 570.

Schritt 2: Die Blockseite erkennen

Ein DataDome-Block kommt als Status 401 oder 403. Enthält seine Seite bereits das Challenge-iframe, übernimmt der Code diese Adresse unverändert, wie es die CapSkip-Dokumentation sagt. Andernfalls baut er die captcha_url aus dem Skriptobjekt dd, wobei der Wert von rt den Pfad bestimmt: /interstitial/ für die Geräteprüfung und /captcha/ für den Slider. Die Tabelle der Dokumentation führt den Parameter t nur für /captcha/ auf, aber das eigene JavaScript der Dokumentation setzt ihn bedingungslos, und ich bin dem JavaScript gefolgt. Alles Unlesbare liefert None, sodass ein gewöhnliches 403 unberührt durchgeht. Neun von Hand gebaute Responses deckten jeden Fall ab, und eine Mock-Geräteprüfung brauchte 1 Task für 2 Seiten. Das Layout stammt aus der CapSkip-Dokumentation, nicht von einer Live-Seite.

# 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)}"

Schritt 3: Pro Cookie-Jar eine Identität halten

Ein Cookie liegt in einem Jar, das über den cookiejar Meta-Key gewählt wird, daher führt die Middleware pro Jar eine Identität: das Cookie, dessen User-Agent, einen Proxy, wenn CapSkip einen gewählt hat, und eine Generationsnummer, die mit jeder Lösung wächst. Ohne die User-Agent-Zeile ging der Retry mit dem Standard-User-Agent von Scrapy hinaus, und vier direkte Seiten endeten mit 3 Tasks und ohne Seite.

Das Cookie geht über das Argument "cookies" hinein, das CookiesMiddleware bei 700 in das Jar kopiert. Es wird nur hinzugefügt, bis eine Anfrage mit ihm zurückgekommen ist, sodass ein Ersatz-Cookie der Website nicht überschrieben wird. Der Mock sendet eines, und eine danach abgerufene Seite trug es ohne neuen Task. Ein Cookie-Header funktioniert nicht, weil CookiesMiddleware den Header aus dem Jar neu aufbaut, und das Abschalten der Cookies ebenso wenig. Beides endete mit 3 Tasks und ohne Seite.

Die Attribute "Domain" und "Path" stammen aus dem Feld "code" des Ergebnisses, das das Cookie so enthält, wie DataDome es gesetzt hat, sodass ein Cookie für eine benannte Website seine Domain behält. Der Mock gab Seiten auf 127.0.0.1 ein 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

Schritt 4: In einem Thread lösen, dann wiederholen

Die Methode datadome von CapSkip blockiert, während sie abfragt. Direkt aus einer Coroutine aufgerufen, hält sie den Reactor an, daher übergibt die Middleware sie an asyncio.to_thread. Das SDK liefert außerdem AsyncCapSkip, dessen Methode datadome Sie awaiten können. Die erneut gesendete Anfrage setzt dont_filter, weil ihre URL den Duplikatfilter bereits passiert hat. Ohne dieses Flag verwarf der Dupefilter beide Retries, und dupefilter/filtered stand auf 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)

Diese Erweiterung tickt alle 50 Millisekunden und erfasst die längste Lücke. Der Crawl hatte eine blockierte Seite, 30 offene Seiten und 8 gleichzeitige Anfragen, der Mock brauchte 3 Sekunden, und nur der Lösungsaufruf wurde geändert. Jede Zeile ist die Spanne von mindestens drei Läufen auf jeder Python-Version.

# 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))
Wie solve das SDK aufruftLängste Tick-Lücke auf einem PC
Direkter Aufruf in der Coroutineetwa 3770 bis 3840 ms
asyncio.to_thread, der Code obenetwa 65 bis 75 ms
AsyncCapSkip in der Coroutine awaitedetwa 220 bis 530 ms
deferToThread mit maybe_deferred_to_futureetwa 65 bis 90 ms
deferToThread ohne Konvertierung awaitedetwa 65 bis 80 ms, Anfrage verloren

AsyncCapSkip, den ich auf jeder Python-Version sechsmal ausgeführt habe, funktioniert, stockt aber länger: Jeder Aufruf von CapSkip baut einen neuen httpx-Client, und das dauerte auf diesem PC etwa 130 bis 190 ms. Die letzte Zeile sieht richtig aus und ist es nicht: Sie löste RuntimeError, Task got bad yield aus, und die Anfrage ging verloren. Die gesamte Middleware braucht außerdem den asyncio-Reactor, den Standard in Scrapy 2.20.0. Unter dem klassischen select-Reactor löste sie einen RuntimeError aus und sendete keinen Task.

Schritt 5: Entscheiden, was jede blockierte Response tut

Anfragen in einem Jar werden gemeinsam blockiert, und jede würde eine Lösung starten. Die erste blockierte Response startet sie und legt sie in self.solving ab, und die anderen im Jar warten darauf. Acht Seiten über einen Proxy ergaben mit diesem Code 1 Task und 8, wenn jede Response für sich löste. Das Setzen von CONCURRENT_REQUESTS_PER_DOMAIN auf 1 verringerte die Blockseiten nicht: Vier Seiten, die ohne Proxy gesendet wurden, sammelten dennoch vier Blockseiten, bevor das erste Cookie eintraf.

DATADOME_MAX_SOLVES begrenzt zwei Zähler, und Sie brauchen beide. Eine Anfrage kann so oft wiederholt werden (dd_tries). Jedes Paar aus Domain und Cookie-Jar kann zwischen zwei durchgekommenen Seiten so viele Lösungen starten (self.spent). Mit der Domain allein als Schlüssel bekamen fünf Jars, die je eine Seite gleichzeitig abriefen (16 Anfragen pro Domain erlaubt), 3 Tasks und verloren 2 Seiten. Mit Domain und Jar als Schlüssel bekamen sie 5 Tasks und 5 Seiten. Eine URL, die jedes Cookie ablehnt, setzte unter 60 guten Seiten das Budget immer wieder zurück, und nur der Zähler pro Anfrage stoppte sie, bei 3 Tasks. Da CapSkip ein unbegrenzter Captcha-Löser mit Pauschallizenz ist, schützen die Limits vor einer Schleife, nicht vor Ihrem Geldbeutel.

    # 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)

Schritt 6: Ein Cookie-Jar pro Proxy

Ein Crawl über mehrere Proxys braucht ein Jar pro Proxy, damit jede Identität genau eine Adresse hat, und der Spider benennt jedes Jar nach seinem Proxy. Scrapy überträgt keinen der beiden Schlüssel auf Anfragen, die Sie aus einer Response bauen: Ein Link, der mit response.follow und ohne meta verfolgt wurde, ging direkt über das Standard-Jar hinaus, wurde blockiert und erneut gelöst. Kopieren Sie die Schlüssel proxy und cookiejar in jede Anfrage, die Sie erzeugen.

Ein von zwei Proxys gemeinsam genutztes Jar ist der andere Fehler: Acht Seiten, auf beide verteilt, endeten in allen drei Läufen auf jeder Python-Version mit 12 Blockseiten statt insgesamt 8, bei einer Anfrage zur Zeit und einer Verzögerung von 0,2 Sekunden. Beide Anordnungen brauchten 2 Tasks.

# 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()}

Beide Listen enthalten Platzhalter; für meinen Lauf habe ich meine Mock-Proxys und -Seiten eingesetzt und sonst nichts geändert. Mit der Vorlagen-Verzögerung von 1 brauchte es 2 Tasks und lud alle 8 Seiten. Scrapy verschiebt einen Proxy-Login in einen Header, bevor die Response zurückkommt, daher behält die Middleware den Proxy so, wie er geschrieben ist; ohne das erhielt mein Mock den Task ohne Login.

# run this in the folder that holds scrapy.cfg
scrapy crawl shop -O out.jsonl

Wenn CapSkip über seine eigene Proxy-Liste löst, nennt das Ergebnis diesen Proxy, und die Identität behält ihn, da das Cookie nur darüber funktioniert. Laut Dokumentation kommt er ohne seinen Login zurück, daher ist ein gelisteter Proxy mit Login ungetestet.

DataDome-403-Fehler, die Ihnen in Scrapy begegnen können

Ich habe jede Zeile in einem Lauf gegen meinen Mock ausgelöst, außer dem fehlenden dd Objekt und einer reinen iframe-Seite, die nur von Hand gebaute Responses abdeckten. Ein abgelehnter Task wird protokolliert und die Seite erneut abgerufen. Eine Ablehnung, die die Adresse nennt, ERROR_PROXY_BANNED oder ERROR_PROXY_CONNECT_REFUSED, wird protokolliert und weitergereicht, weil ein Retry über diese Adresse laut Dokumentation erneut scheitert. Mein Mock lieferte beide zum Zeitpunkt des Ergebnisses, und ich habe sie nicht gegen die echte App ausgelöst. Jeder andere SDK-Fehler wird protokolliert und weitergereicht.

Was Sie sehenUrsacheBeheben
TypeError wegen eines unerwarteten Schlüsselwortarguments "spider"Scrapy 2.13 oder älterAktualisieren Sie auf 2.14 oder neuer
RuntimeError: Task got bad yieldEin Deferred, das direkt in einer Coroutine awaited wirdVerwenden Sie asyncio.to_thread oder maybe_deferred_to_future
403-Seiten erreichen HttpErrorMiddleware, und es wird kein Task gesendetDie Middleware-Nummer liegt über 590, oder die Blockseite hat weder eine iframe-Adresse noch ein dd ObjektNehmen Sie 551 bis 589 und suchen Sie in der Blockseite nach einem von beiden
Seiten bleiben blockiert, und in den Stats erscheint ein Zähler budget_used_upCookies aus, ein Cookie-Header oder ein geänderter User-AgentVergleichen Sie den Retry mit der Identität
ERROR_PROXY_BANNED oder ERROR_PROXY_CONNECT_REFUSED im LogCapSkip meldet die Adresse als gesperrt oder nicht erreichbarWechseln Sie den Proxy für dieses Jar
ValidationException mit t=bv im LogDie Blockseite sagt, die Adresse sei gesperrtWechseln Sie den Proxy für dieses Jar
NetworkException im LogUnter Host und Port in settings.py antwortet nichtsStarten Sie CapSkip und prüfen Sie beides

Regeln zur Reihenfolge stehen in der Referenz zur Downloader-Middleware des Scrapy-Projekts. Dieselbe Idee für reCAPTCHA finden Sie im Leitfaden zur Scrapy-Captcha-Middleware, und zum Crawlen in großem Umfang siehe die Seite zu Web Scraping.

CapSkip auf einem Server betreiben

Der Server-Modus lässt CapSkip auf Ihrer Netzwerkadresse oder einer öffentlichen IP antworten, sodass ein Crawler auf einem anderen PC oder einem Windows-VPS es erreichen kann. Wählen Sie ihn in den Verbindungseinstellungen von CapSkip und tragen Sie die Adresse dieses Rechners in DATADOME_CAPSKIP_HOST ein; sonst ändert sich nichts. Das Starten des Server-Modus lässt den CapSkip-Port für jede Adresse offen, also fügen Sie eine Windows-Firewall-Regel hinzu, die die Rechner blockiert, die ihn nicht erreichen dürfen. Die Lösung läuft auf dem Server, daher wird das Cookie von dessen Adresse aus erlangt, sofern die Anfrage keinen Proxy trägt, den die Middleware weitergibt. Nichts davon habe ich ausgeführt, nur einen Mock auf 127.0.0.1, und bei aktivierter API Key Validation würden Sie apiKey an den CapSkip-Konstruktor übergeben.

FAQ

Kann ich AsyncCapSkip awaiten, statt einen Thread zu verwenden?

Ja. Bauen Sie AsyncCapSkip anstelle von CapSkip auf und awaiten Sie dessen Methode datadome in self.solve. Es ergab auf beiden Python-Versionen dieselben Zahlen wie der Thread, mit einem längeren Stocken von etwa 220 bis 530 ms auf meinem PC.

Wie viele Lösungen braucht ein echter DataDome-Scrapy-Crawl?

Das kann ich nicht sagen. Im Mock war es eine pro Proxy, weil der Mock ein Cookie nie ablaufen lässt. Der Stats-Schlüssel datadome/solves zählt die Lösungen in Ihrem eigenen Crawl.