DataDome Scrapy 403 blocks को middleware से कैसे हल करें

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

Scrapy में DataDome संभालने के लिए पूरा काम एक ही downloader middleware में रखें। यह 403 block page पहचानता है, Python SDK के datadome मेथड से CapSkip से datadome cookie लेता है, और उसी cookie, उसके User-Agent और उसी proxy के साथ request दोबारा भेजता है। DataDome Scrapy सेटअप की सफलता priority नंबर, duplicate filter, ब्लॉक करने वाली SDK call और हर proxy के लिए अलग 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 पर middleware TypeError के साथ विफल होता है, क्योंकि वह रिलीज़ अब भी हर middleware मेथड को "spider" पास करता है।
  • capskip 1.5.0 या उससे नया, जिसमें datadome मेथड पहली बार आया।
  • वह address जिस पर CapSkip जवाब देता है: Local mode में 127.0.0.1, जो सिर्फ़ उसी PC तक पहुँचता है, या Server mode में आपका network या public IP।
  • हर crawl identity के लिए एक sticky proxy, पूरे URL के रूप में, जैसे http://user:[email protected]:8080। जो proxy हर कनेक्शन पर अपना exit IP बदलता है, वह काम करने वाली cookie नहीं बना सकता, ऐसा CapSkip docs कहते हैं।

PowerShell प्रॉम्प्ट में वह प्रोजेक्ट बनाइए जिसमें नीचे के सारे ब्लॉक जाएँगे। फ़ाइल नाम उस फ़ोल्डर के सापेक्ष हैं जिसमें scrapy.cfgहै, और जो ब्लॉक किसी फ़ाइल से शुरू होता है वह बनी-बनाई फ़ाइल की जगह ले लेता है।

pip install scrapy capskip
scrapy startproject shop
cd shop

मैंने अपने लिखे mock सर्वरों पर टेस्ट किया, न किसी असली DataDome साइट पर और न CapSkip ऐप पर। एक mock CapSkip API docs की in.php और res.php जाँचों की नकल करता है। दूसरा तब तक 403 देता है जब तक request में पहले mock की जारी की हुई cookie न हो, और वह भी उसी User-Agent और proxy के लिए जिसके लिए वह जारी हुई थी; बाइंडिंग के ये नियम CapSkip docs से आए हैं, DataDome से नहीं। मैंने Python 3.11.7 और 3.14.0 चलाए। जब तक अलग से न कहा जाए, गिनतियाँ Scrapy 2.20.0 और capskip 1.7.0 से आई हैं, जिनमें DOWNLOAD_DELAY 0 पर था और mock 0.4 सेकंड में हल करता था, और दोनों Python पर नतीजे मिले। Scrapy 2.14.0 के साथ capskip 1.5.0 और Scrapy 2.19.0 के साथ capskip 1.6.0 ने कुछ मामलों में वही गिनतियाँ दीं।

DataDome Scrapy middleware बनाएँ

चरण 1: priority नंबर चुनें

Scrapy process_request को नंबरों के बढ़ते क्रम में और process_response को घटते क्रम में बुलाता है, इसलिए बड़ा नंबर downloader के ज़्यादा पास बैठता है। 590 पर HttpCompressionMiddleware बॉडी को unzip करता है, इसलिए block page पढ़ने के लिए हमारा नंबर 590 से कम होना चाहिए। 550 पर RetryMiddleware responses को retries में बदलता है, इसलिए हमारा नंबर उससे ज़्यादा होना चाहिए ताकि हम उन्हें पहले देखें। इससे 551 से 589 बचते हैं, और चूँकि 580 MetaRefreshMiddleware का है, settings में 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 किया हुआ block page middleware तक बाइट्स 1f 8b के रूप में पहुँचा और 403 निकल गया; 570 पर वह हल हो गया। 403 को RETRY_HTTP_CODES में रखने पर mock साइट ने 540 पर हल से पहले 3 block pages दिए और 570 पर 1।

चरण 2: block page पहचानें

DataDome का block 401 या 403 स्टेटस के रूप में आता है। जब उसके पेज में पहले से challenge iframe होता है, तो कोड उस address को जस का तस लेता है, जैसा CapSkip docs कहते हैं। वरना वह captcha_url को script ऑब्जेक्ट dd से बनाता है, जहाँ rt का मान path चुनता है: device check के लिए /interstitial/ और slider के लिए /captcha/। docs की तालिका t पैरामीटर सिर्फ़ /captcha/ के लिए बताती है, लेकिन docs का अपना JavaScript उसे बिना शर्त सेट करता है, और मैंने JavaScript का पालन किया। जो कुछ पढ़ा न जा सके वह None लौटाता है, इसलिए सामान्य 403 बिना छुए निकल जाता है। नौ हाथ से बने responses ने हर स्थिति को कवर किया, और एक mock device check में 2 पेज पर 1 task लगा। यह layout CapSkip docs से लिया गया है, किसी लाइव पेज से नहीं।

# 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 के लिए एक identity रखें

cookie उस jar में रहती है जिसे cookiejar meta key चुनती है, इसलिए middleware हर jar के लिए एक identity रखता है: cookie, उसका User-Agent, proxy (जब CapSkip ने कोई चुना हो), और एक generation नंबर जो हर solve के साथ बढ़ता है। User-Agent वाली लाइन के बिना retry Scrapy के डिफ़ॉल्ट User-Agent के साथ गया, और चार direct पेज 3 tasks और बिना किसी पेज के खत्म हुए।

cookie "cookies" argument के ज़रिए अंदर जाती है, जिसे 700 पर CookiesMiddleware jar में कॉपी करता है। इसे सिर्फ़ तब तक जोड़ा जाता है जब तक इसे लिए हुए एक request लौट न आए, इसलिए साइट की भेजी replacement cookie ओवरराइट नहीं होती। mock एक भेजता है, और उसके बाद fetch किए गए पेज ने बिना नए task के उसे साथ रखा। Cookie header काम नहीं करता, क्योंकि CookiesMiddleware header को jar से दोबारा बनाता है, और cookies बंद करना भी काम नहीं करता। दोनों 3 tasks और बिना किसी पेज के खत्म हुए।

"Domain" और "Path" attributes result के "code" फ़ील्ड से आते हैं, जिसमें cookie वैसी ही होती है जैसी DataDome ने सेट की थी, इसलिए किसी नामित साइट की cookie अपना domain रखती है। mock ने 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: thread में हल करें, फिर retry करें

CapSkip का datadome मेथड poll करते समय ब्लॉक करता है। coroutine से सीधे बुलाने पर वह reactor को रोक लेता है, इसलिए middleware उसे asyncio.to_thread को सौंप देता है। SDK में AsyncCapSkip भी आता है, जिसके datadome मेथड को आप await कर सकते हैं। retry किया गया request dont_filter सेट करता है, क्योंकि उसका URL duplicate filter से पहले ही गुज़र चुका है। इसके बिना dupefilter ने दोनों retries हटा दिए, और 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)

यह extension हर 50 मिलीसेकंड पर tick करता है और सबसे लंबा gap दर्ज करता है। crawl में एक blocked पेज, 30 खुले पेज और एक साथ 8 requests थे, mock को 3 सेकंड लगे, और सिर्फ़ solve call बदली। हर पंक्ति हर 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 पर सबसे लंबा tick gap
coroutine के भीतर सीधी callलगभग 3770 से 3840 ms
asyncio.to_thread, ऊपर वाला कोडलगभग 65 से 75 ms
coroutine में await किया गया AsyncCapSkipलगभग 220 से 530 ms
deferToThread के साथ maybe_deferred_to_futureलगभग 65 से 90 ms
deferToThread, बिना conversion के await किया गयालगभग 65 से 80 ms, request खो गया

AsyncCapSkip, जिसे मैंने हर Python पर छह बार चलाया, काम करता है पर ज़्यादा देर अटकता है: CapSkip को हर call एक नया httpx client बनाती है, और उसे बनाने में इस PC पर लगभग 130 से 190 ms लगे। आखिरी पंक्ति सही दिखती है पर है नहीं: उसने RuntimeError, Task got bad yield उठाया और request खो गया। पूरे middleware को asyncio reactor भी चाहिए, जो Scrapy 2.20.0 में डिफ़ॉल्ट है। क्लासिक select reactor के तहत उसने RuntimeError उठाया और कोई task नहीं भेजा।

चरण 5: तय करें कि हर blocked response क्या करे

एक jar के requests साथ-साथ block होते हैं, और हर एक solve शुरू कर देगा। पहला blocked response solve शुरू करता है और उसे self.solving में रखता है, और jar के बाकी responses उसका इंतज़ार करते हैं। एक proxy से आठ पेजों पर इस कोड से 1 task बना, और जब हर response ने अपने लिए solve किया तो 8। CONCURRENT_REQUESTS_PER_DOMAIN को 1 पर सेट करने से block pages कम नहीं हुए: बिना proxy के भेजे गए चार पेजों ने पहली cookie आने से पहले फिर भी चार block pages जमा किए।

DATADOME_MAX_SOLVES दो गिनतियों की सीमा तय करता है, और आपको दोनों चाहिए। एक request को इतनी बार retry किया जा सकता है (dd_tries)। domain और cookie jar की हर जोड़ी पास हो चुके पेजों के बीच इतने solve शुरू कर सकती है (self.spent)। सिर्फ़ domain से keyed करने पर, पाँच jars ने, जिनमें से हर एक ने एक साथ एक पेज लिया (हर domain पर 16 requests की अनुमति), 3 tasks लिए और 2 पेज खो दिए। domain और jar से keyed करने पर उन्हें 5 tasks और 5 पेज मिले। एक URL जो हर cookie ठुकराता है, 60 अच्छे पेजों के बीच, budget को बार-बार रीसेट करता रहा, और सिर्फ़ प्रति-request गिनती ने उसे 3 tasks पर रोका। चूँकि CapSkip एक असीमित कैप्चा सॉल्वर है और फिक्स्ड कीमत वाले लाइसेंस पर चलता है, इसलिए ये सीमाएँ loop से बचाती हैं, आपके वॉलेट से नहीं।

    # 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: हर proxy के लिए एक cookie jar

कई proxies से गुज़रने वाले crawl को हर proxy के लिए एक jar चाहिए, ताकि हर identity का एक ही address हो, और spider हर jar का नाम उसके proxy के नाम पर रखता है। Scrapy इनमें से कोई भी key उन requests तक नहीं ले जाता जो आप किसी response से बनाते हैं: वह link जो response.follow से बिना meta के follow किया गया, डिफ़ॉल्ट jar से सीधे गया, block हुआ और दोबारा हल हुआ। जो भी request आप बनाएँ, उसमें proxy और cookiejar keys कॉपी कर दीजिए।

दो proxies के बीच साझा एक jar दूसरी गलती है: उनके बीच बँटे आठ पेज 8 के बजाय 12 block pages के साथ खत्म हुए, हर Python पर तीनों रन में, एक बार में एक request पर और 0.2 सेकंड की देरी के साथ। दोनों layouts में 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()}

दोनों lists में placeholders हैं; अपने रन के लिए मैंने अपने mock proxies और पेज लगाए और बाकी कुछ नहीं बदला। template की देरी 1 के साथ 2 tasks लगे और सभी 8 पेज लोड हुए। Scrapy response लौटने से पहले proxy login को header में डाल देता है, इसलिए middleware proxy को वैसा ही रखता है जैसा लिखा गया; इसके बिना मेरे mock को login के बिना task मिला।

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

जब CapSkip अपनी ही proxy list से हल करता है, तो result उस proxy का नाम बताता है और identity उसे रखती है, क्योंकि cookie सिर्फ़ उसी से काम करती है। docs कहते हैं कि वह login के बिना लौटता है, इसलिए login वाला listed proxy परीक्षण से बाहर है।

Scrapy में आपको मिल सकने वाले DataDome 403 errors

मैंने mock के सामने एक रन में हर पंक्ति को भड़काया, सिवाय गायब dd ऑब्जेक्ट और सिर्फ़ iframe वाले पेज के, जिन्हें सिर्फ़ हाथ से बने responses ने कवर किया। ठुकराया गया task log होता है और पेज दोबारा fetch होता है। जो ठुकराव address का नाम बताता है, ERROR_PROXY_BANNED या ERROR_PROXY_CONNECT_REFUSED, log होकर आगे बढ़ा दिया जाता है, क्योंकि docs कहते हैं कि उसी address से retry फिर विफल होगा। मेरे mock ने दोनों result के समय लौटाए, और मैंने असली ऐप पर उन्हें नहीं भड़काया। कोई भी दूसरी SDK error log होकर आगे बढ़ा दी जाती है।

आप जो देखते हैंकारणफिक्स
अनपेक्षित keyword argument "spider" वाला TypeErrorScrapy 2.13 या उससे पुराना2.14 या उसके बाद वाले वर्शन पर अपग्रेड करें
RuntimeError: Task got bad yieldcoroutine में सीधे await किया गया Deferredasyncio.to_thread या maybe_deferred_to_future इस्तेमाल करें
403 पेज HttpErrorMiddleware तक पहुँचते हैं और कोई task नहीं भेजा जाताmiddleware का नंबर 590 से ऊपर है, या block page में न iframe address है और न ही dd ऑब्जेक्ट551 से 589 इस्तेमाल करें और block page में इनमें से कोई एक देखें
पेज blocked रहते हैं और stats में budget_used_up की गिनती दिखती हैcookies बंद हैं, Cookie header है या User-Agent बदला हुआ हैretry की तुलना identity से करें
log में ERROR_PROXY_BANNED या ERROR_PROXY_CONNECT_REFUSEDCapSkip address को banned या पहुँच से बाहर बताता हैउस jar के लिए proxy बदलें
ValidationException, साथ में t=bv log मेंblock page कहता है कि address banned हैउस jar के लिए proxy बदलें
log में NetworkExceptionsettings.py के host और port पर कोई जवाब नहीं देताCapSkip शुरू करें और दोनों जाँचें

Ordering के नियम downloader middleware संदर्भ में मिलते हैं, जो Scrapy प्रोजेक्ट का है। यही विचार reCAPTCHA पर लागू हुआ देखना हो तो Scrapy CAPTCHA middleware गाइड देखें, और बड़े पैमाने पर crawling के लिए यह पेज देखें: वेब स्क्रैपिंग पेज.

सर्वर पर CapSkip चलाना

Server mode में CapSkip आपके network address या किसी public IP पर जवाब देता है, इसलिए दूसरे PC पर चल रहा crawler या कोई Windows VPS उस तक पहुँच सकता है। इसे CapSkip की कनेक्शन सेटिंग्स में चुनें और उस मशीन का address DATADOME_CAPSKIP_HOST में डालें; बाकी कुछ नहीं बदलता। Server mode शुरू करने पर CapSkip का port हर address के लिए खुला रहता है, इसलिए एक Windows Firewall block rule जोड़ें जो उन मशीनों को रोके जिन्हें इस तक नहीं पहुँचना चाहिए। solve server पर चलता है, इसलिए cookie उसी के address से कमाई जाती है, जब तक request में proxy न हो, जिसे middleware आगे भेज देता है। मैंने इनमें से कुछ नहीं चलाया, सिर्फ़ 127.0.0.1 पर एक mock चलाया, और API Key Validation चालू होने पर आप CapSkip constructor को apiKey देंगे।

FAQ

क्या thread की जगह मैं AsyncCapSkip को await कर सकता हूँ?

हाँ। CapSkip की जगह AsyncCapSkip बनाइए और उसके datadome मेथड को self.solve में await कीजिए। इसने दोनों Python पर thread जैसी ही गिनतियाँ दीं, पर मेरे PC पर लगभग 220 से 530 ms का ज़्यादा लंबा stall रहा।

असली DataDome Scrapy crawl को कितने solves चाहिए होंगे?

मैं नहीं कह सकता। mock में हर proxy पर एक था, क्योंकि mock कभी cookie expire नहीं करता। stats key datadome/solves आपके अपने crawl के solves गिनती है।