Scrapy’de DataDome 403 Engellerini Bir Middleware ile Çözme

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

Scrapy’de DataDome’ı ele almak için işi tek bir downloader middleware’e koyun. O, 403 engelleme sayfasını fark eder, Python SDK’nın datadome metoduyla CapSkip’ten bir datadome cookie’si alır ve isteği o cookie, onun User-Agent’ı ve aynı proxy ile yeniden dener. Bir DataDome Scrapy kurulumunun kaderini öncelik numarası, yinelenen filtresi, engelleyici bir SDK çağrısı ve proxy başına bir cookie jar belirler. Bu kılavuzda CapSkip DataDome çözücüsü bir Scrapy projesine bağlanır ve her tercihin benim çalıştırmalarımda ne yaptığı raporlanır.

Neye ihtiyacınız var

  • CapSkip 3.2.0 veya üzeri kurulu bir Windows bilgisayarı; DataDome desteği olan ilk sürüm budur. CapSkip’i kurup başlatma adımları kurulum kılavuzu içinde anlatılır.
  • Python 3.11 veya üzeri; Scrapy 2.20, w3lib ve itemadapter hepsi bunu gerektirir.
  • Scrapy 2.14 veya üzeri. 2.13.4 sürümünde middleware bir TypeError ile başarısız olur, çünkü o sürüm hâlâ her middleware metoduna "spider" değerini geçirir.
  • capskip 1.5.0 veya üzeri; datadome metodu olan ilk sürüm.
  • CapSkip’in yanıt verdiği adres: Local modunda yalnızca aynı bilgisayara ulaşan 127.0.0.1, Server modunda ise ağ adresiniz veya genel IP’niz.
  • Her tarama kimliği için tek bir sabit (sticky) proxy, tam bir URL olarak, örneğin http://user:[email protected]:8080. Her bağlantıda çıkış IP’sini değiştiren bir proxy çalışan bir cookie üretemez, diyor CapSkip belgeleri.

Bir PowerShell isteminde, aşağıdaki tüm blokların gireceği projeyi oluşturun. Dosya adları, scrapy.cfg dosyasının bulunduğu klasöre göredir; bir dosyayı başlatan blok, oluşturulan dosyanın yerini alır.

pip install scrapy capskip
scrapy startproject shop
cd shop

Gerçek bir DataDome sitesine ve CapSkip uygulamasına değil, kendi yazdığım sahte (mock) sunucuların karşısında test ettim. Biri CapSkip API belgelerindeki in.php ve res.php kontrollerini kopyalar. Diğeri, istek ilkinin verdiği bir cookie taşımadıkça, o cookie’nin verildiği User-Agent ve proxy için 403 yanıtı verir; bu bağlama kuralları DataDome’dan değil, CapSkip belgelerinden gelir. Python 3.11.7 ve 3.14.0 çalıştırdım. Aksi belirtilmedikçe sayılar Scrapy 2.20.0 ve capskip 1.7.0 ile, DOWNLOAD_DELAY değeri 0 ve 0,4 saniyede çözen bir mock ile alındı ve iki Python’da da aynı çıktı. Scrapy 2.14.0 ile capskip 1.5.0 ve Scrapy 2.19.0 ile capskip 1.6.0, birkaç durumda aynı sayıları verdi.

DataDome Scrapy middleware’ini oluşturun

1. Adım: öncelik numarasını seçin

Scrapy process_request metodunu numaraların artan sırasıyla ve process_response metodunu azalan sırasıyla çağırır, bu yüzden daha büyük bir numara downloader’a daha yakın durur. HttpCompressionMiddleware 590’da gövdeyi açar, bu yüzden engelleme sayfasını okumak için bizim numaramız 590’dan düşük olmalıdır. RetryMiddleware 550’de yanıtları yeniden denemelere çevirir, bu yüzden onları önce görmek için bizimki bundan yüksek olmalıdır. Geriye 551 ile 589 kalır ve 580 MetaRefreshMiddleware’e ait olduğundan ayarlar 570 kullanır. Aşağıdaki bloklar tek bir proje oluşturur, sırayla yapıştırılır ve hiçbiri tek başına çalışmaz.

# 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’de gzip’li bir engelleme sayfası middleware’e 1f 8b baytları olarak ulaştı ve 403 geçip gitti; 570’te çözüldü. 403 kodu RETRY_HTTP_CODES ayarındayken mock site, çözümden önce 540’ta 3, 570’te 1 engelleme sayfası sundu.

2. Adım: engelleme sayfasını fark edin

Bir DataDome engeli 401 veya 403 durumuyla gelir. Sayfası challenge iframe’ini zaten içeriyorsa kod, CapSkip belgelerinin dediği gibi o adresi olduğu gibi alır. Aksi hâlde captcha_url değerini script nesnesi dd içinden kurar, yolu rt değeri seçer: cihaz denetimi için /interstitial/, kaydırıcı için /captcha/. Belge tablosu t parametresini yalnızca /captcha/ için listeler, ama belgelerin kendi JavaScript’i onu koşulsuz ayarlar ve ben JavaScript’i izledim. Okunamayan her şey None döndürür, böylece sıradan bir 403 olduğu gibi geçer. Elle hazırlanmış dokuz yanıt her durumu kapsadı ve bir mock cihaz denetimi 2 sayfa için 1 görev aldı. Düzen, canlı bir sayfadan değil CapSkip belgelerinden gelir.

# 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. Adım: cookie jar başına bir kimlik tutun

Bir cookie, cookiejar meta anahtarının seçtiği bir jar içinde durur; bu yüzden middleware jar başına bir kimlik tutar: cookie, onun User-Agent’ı, CapSkip bir tane seçtiyse bir proxy ve her çözümde artan bir nesil numarası. User-Agent satırı olmadan yeniden deneme varsayılan Scrapy User-Agent’ı ile gitti ve doğrudan giden dört sayfa 3 görevle ve hiç sayfa alınmadan bitti.

Cookie, "cookies" argümanı üzerinden girer; 700’deki CookiesMiddleware onu jar’a kopyalar. Yalnızca onu taşıyan bir istek geri dönene kadar eklenir, böylece siteden gelen yedek bir cookie ezilmez. Mock bir tane gönderir ve sonradan çekilen bir sayfa onu yeni bir görev olmadan taşıdı. Bir Cookie başlığı işe yaramaz, çünkü CookiesMiddleware başlığı jar’dan yeniden kurar; cookie’leri kapatmak da yaramaz. İkisi de 3 görevle ve hiç sayfa alınmadan bitti.

"Domain" ve "Path" öznitelikleri, cookie’yi DataDome’un ayarladığı hâliyle tutan sonucun "code" alanından gelir; bu yüzden adı verilmiş bir site için cookie kendi domain’ini korur. Mock, 127.0.0.1 üzerindeki sayfalara yalnızca host’a bağlı bir cookie verdi.

# 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. Adım: bir iş parçacığında çözün, sonra yeniden deneyin

CapSkip’in datadome metodu yoklarken engeller. Doğrudan bir coroutine içinden çağrılırsa reactor’ı tutar; bu yüzden middleware onu asyncio.to_thread ile bir iş parçacığına devreder. SDK ayrıca AsyncCapSkip sınıfını da getirir; onun datadome metodunu await edebilirsiniz. Yeniden denenen istek dont_filter ayarını yapar, çünkü URL’si yinelenen filtresinden zaten geçmiştir. Bu olmadan dupefilter iki yeniden denemeyi de düşürdü ve dupefilter/filtered değeri 2 çıktı.

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

Bu eklenti her 50 milisaniyede bir tik atar ve en uzun aralığı kaydeder. Taramada bir engellenmiş sayfa, 30 açık sayfa ve aynı anda 8 istek vardı, mock 3 saniye sürdü ve yalnızca solve çağrısı değişti. Her satır, her Python’da en az üç çalıştırmanın aralığıdır.

# 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’yı nasıl çağırıyorBir bilgisayarda en uzun tik aralığı
Coroutine içinde doğrudan çağrıyaklaşık 3770 ile 3840 ms
asyncio.to_thread, yukarıdaki kodyaklaşık 65 ile 75 ms
Coroutine içinde await edilen AsyncCapSkipyaklaşık 220 ile 530 ms
maybe_deferred_to_future ile deferToThreadyaklaşık 65 ile 90 ms
Dönüştürme yapılmadan await edilen deferToThreadyaklaşık 65 ile 80 ms, istek kayboldu

Her Python’da altı kez çalıştırdığım AsyncCapSkip çalışır ama daha uzun takılır: CapSkip’e yapılan her çağrı yeni bir httpx istemcisi oluşturur ve birini oluşturmak bu bilgisayarda yaklaşık 130 ile 190 ms sürdü. Son satır doğru görünür ama değildir: RuntimeError, Task got bad yield hatası verdi ve istek kayboldu. Middleware’in tamamı ayrıca asyncio reactor ister; Scrapy 2.20.0’da varsayılan odur. Klasik select reactor altında bir RuntimeError verdi ve hiçbir görev göndermedi.

5. Adım: engellenen her yanıtın ne yapacağına karar verin

Bir jar içindeki istekler birlikte engellenir ve her biri bir çözüm başlatırdı. İlk engellenen yanıt çözümü başlatır ve onu self.solving içinde saklar; jar içindeki diğerleri onu bekler. Tek bir proxy üzerinden sekiz sayfa bu kodla 1 görev, her yanıt kendi başına çözdüğünde ise 8 görev üretti. CONCURRENT_REQUESTS_PER_DOMAIN değerini 1 yapmak engelleme sayfalarını azaltmadı: proxy olmadan gönderilen dört sayfa, ilk cookie gelmeden önce yine dört engelleme sayfası topladı.

DATADOME_MAX_SOLVES iki sayacı sınırlar ve ikisine de ihtiyacınız var. Bir istek en fazla bu kadar kez yeniden denenebilir (dd_tries). Her alan adı ve cookie jar çifti, geçen sayfalar arasında en fazla bu kadar çözüm başlatabilir (self.spent). Yalnızca alan adına göre anahtarlandığında, her biri aynı anda bir sayfa çeken beş jar (alan adı başına 16 isteğe izin var) 3 görev aldı ve 2 sayfa kaybetti. Alan adı ve jar’a göre anahtarlandıklarında 5 görev ve 5 sayfa aldılar. 60 iyi sayfa arasındaki, her cookie’yi reddeden bir URL bütçeyi sıfırlayıp durdu ve onu yalnızca istek başına sayım durdurdu, 3 görevde. CapSkip, sabit bir lisansla çalışan bir sınırsız captcha çözücü olduğu için bu sınırlar cüzdanınızı değil, bir döngüyü korur.

    # 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. Adım: proxy başına bir cookie jar

Birden çok proxy üzerinden yapılan bir tarama, proxy başına bir jar ister; böylece her kimliğin tek bir adresi olur ve spider her jar’ı proxy’sinin adıyla adlandırır. Scrapy iki anahtarı da bir response’tan oluşturduğunuz isteklere taşımaz: bir bağlantı response.follow ile ve meta olmadan izlendiğinde istek varsayılan jar üzerinden doğrudan gitti, engellendi ve yeniden çözüldü. Proxy ve cookiejar anahtarlarını oluşturduğunuz her isteğe kopyalayın.

İki proxy’nin paylaştığı tek jar öteki hatadır: onlara bölünen sekiz sayfa, her Python’daki üç çalıştırmanın üçünde de 8 yerine 12 engelleme sayfasıyla bitti; aynı anda bir istek ve 0,2 saniyelik gecikme ile. İki düzen de 2 görev aldı.

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

İki liste de yer tutucu içerir; çalıştırmam için mock proxy’lerimi ve sayfalarımı koydum ve başka hiçbir şeyi değiştirmedim. Şablondaki 1 gecikmeyle 2 görev aldı ve 8 sayfanın hepsini yükledi. Scrapy, yanıt gelmeden önce proxy girişini bir başlığa taşır; bu yüzden middleware proxy’yi yazıldığı gibi tutar; bu olmasaydı mock’um görevi girişsiz aldı.

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

CapSkip kendi proxy listesi üzerinden çözdüğünde, sonuç o proxy’yi adıyla verir ve kimlik onu tutar, çünkü cookie yalnızca o proxy üzerinden çalışır. Belgelere göre proxy girişi olmadan geri gelir; bu yüzden girişli bir liste proxy’si test edilmedi.

Scrapy’de karşılaşabileceğiniz DataDome 403 hataları

Her satırı mock’a karşı bir çalıştırmada tetikledim, eksik dd nesnesi ve yalnızca iframe içeren bir sayfa hariç; o ikisini yalnızca elle hazırlanmış yanıtlar kapsadı. Reddedilen bir görev günlüğe yazılır ve sayfa yeniden çekilir. Adresi adıyla anan bir ret, ERROR_PROXY_BANNED veya ERROR_PROXY_CONNECT_REFUSED, günlüğe yazılır ve olduğu gibi geçirilir, çünkü belgelere göre o adres üzerinden bir yeniden deneme yine başarısız olur. Mock’um ikisini de sonuç anında döndürdü ve onları gerçek uygulamaya karşı tetiklemedim. Diğer her SDK hatası günlüğe yazılır ve olduğu gibi geçirilir.

GördüğünüzNedenDüzeltme
"spider" adlı beklenmeyen bir anahtar sözcük argümanı hakkında TypeErrorScrapy 2.13 veya daha eski2.14 veya üzerine yükseltin
RuntimeError: Task got bad yieldBir coroutine içinde doğrudan await edilen bir Deferredasyncio.to_thread ya da maybe_deferred_to_future kullanın
403 sayfaları HttpErrorMiddleware’e ulaşır ve hiçbir görev gönderilmezMiddleware numarası 590’ın üzerinde ya da engelleme sayfası ne bir iframe adresi ne de bir dd nesnesi içeriyor551 ile 589 arasını kullanın ve engelleme sayfasında ikisinden birini arayın
Sayfalar engelli kalır ve istatistiklerde bir budget_used_up sayacı görünürCookie’ler kapalı, bir Cookie başlığı ya da değiştirilmiş bir User-AgentYeniden denemeyi kimlikle karşılaştırın
Günlükte ERROR_PROXY_BANNED veya ERROR_PROXY_CONNECT_REFUSEDCapSkip adresi yasaklı ya da ulaşılamaz olarak bildiriyorO jar için proxy’yi değiştirin
Günlükte ValidationException, mesajında t=bv geçiyorEngelleme sayfası adresin yasaklı olduğunu söylüyorO jar için proxy’yi değiştirin
Günlükte NetworkExceptionsettings.py içindeki host ve portta hiçbir şey yanıt vermiyorCapSkip’i başlatın ve ikisini de kontrol edin

Sıralama kuralları Scrapy projesinin downloader middleware referansı içinde yer alır. Aynı fikrin reCAPTCHA’ya uygulanışı Scrapy CAPTCHA middleware rehberinde anlatılır; ölçekli tarama ise web scraping sayfasında.

CapSkip’i bir sunucuda çalıştırmak

Server modu, CapSkip’in ağ adresinizde ya da genel bir IP’de yanıt vermesini sağlar; böylece başka bir bilgisayardaki bir crawler ya da bir Windows VPS ona ulaşabilir. Bunu CapSkip’in bağlantı ayarları bölümünden seçin ve o makinenin adresini DATADOME_CAPSKIP_HOST değişkenine yazın; başka hiçbir şey değişmez. Server modunu başlatmak CapSkip portunu her adrese açık bırakır; bu yüzden ulaşmaması gereken makineleri engelleyen bir Windows Firewall kuralı ekleyin. Çözüm sunucuda çalışır, bu yüzden istek bir proxy taşımadıkça cookie o sunucunun adresinden kazanılır; middleware proxy’yi iletir. Bunların hiçbirini çalıştırmadım, yalnızca 127.0.0.1 üzerindeki bir mock’u denedim ve API Key Validation açıkken apiKey’i CapSkip yapıcısına verirdiniz.

FAQ

Bir iş parçacığı yerine AsyncCapSkip’i await edebilir miyim?

Evet. CapSkip yerine AsyncCapSkip oluşturun ve datadome metodunu self.solve içinde await edin. İki Python’da da iş parçacığıyla aynı sayıları verdi; bilgisayarımda yaklaşık 220 ile 530 ms’lik daha uzun bir takılma ile.

Gerçek bir DataDome Scrapy taraması kaç çözüm gerektirir?

Bilemem. Mock’ta proxy başına bir tane oldu, çünkü mock hiçbir cookie’nin süresini doldurmaz. İstatistik anahtarı datadome/solves kendi taramanızdaki çözümleri sayar.