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

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 pagesBei 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.generationSchritt 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 aufruft | Längste Tick-Lücke auf einem PC |
|---|---|
| Direkter Aufruf in der Coroutine | etwa 3770 bis 3840 ms |
| asyncio.to_thread, der Code oben | etwa 65 bis 75 ms |
| AsyncCapSkip in der Coroutine awaited | etwa 220 bis 530 ms |
| deferToThread mit maybe_deferred_to_future | etwa 65 bis 90 ms |
| deferToThread ohne Konvertierung awaited | etwa 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 sehen | Ursache | Beheben |
|---|---|---|
| TypeError wegen eines unerwarteten Schlüsselwortarguments "spider" | Scrapy 2.13 oder älter | Aktualisieren Sie auf 2.14 oder neuer |
| RuntimeError: Task got bad yield | Ein Deferred, das direkt in einer Coroutine awaited wird | Verwenden Sie asyncio.to_thread oder maybe_deferred_to_future |
| 403-Seiten erreichen HttpErrorMiddleware, und es wird kein Task gesendet | Die Middleware-Nummer liegt über 590, oder die Blockseite hat weder eine iframe-Adresse noch ein dd Objekt | Nehmen 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_up | Cookies aus, ein Cookie-Header oder ein geänderter User-Agent | Vergleichen Sie den Retry mit der Identität |
| ERROR_PROXY_BANNED oder ERROR_PROXY_CONNECT_REFUSED im Log | CapSkip meldet die Adresse als gesperrt oder nicht erreichbar | Wechseln Sie den Proxy für dieses Jar |
ValidationException mit t=bv im Log | Die Blockseite sagt, die Adresse sei gesperrt | Wechseln Sie den Proxy für dieses Jar |
| NetworkException im Log | Unter Host und Port in settings.py antwortet nichts | Starten 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.
