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

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 pages650’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.generation4. 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ıyor | Bir bilgisayarda en uzun tik aralığı |
|---|---|
| Coroutine içinde doğrudan çağrı | yaklaşık 3770 ile 3840 ms |
| asyncio.to_thread, yukarıdaki kod | yaklaşık 65 ile 75 ms |
| Coroutine içinde await edilen AsyncCapSkip | yaklaşık 220 ile 530 ms |
| maybe_deferred_to_future ile deferToThread | yaklaşık 65 ile 90 ms |
| Dönüştürme yapılmadan await edilen deferToThread | yaklaşı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üz | Neden | Düzeltme |
|---|---|---|
| "spider" adlı beklenmeyen bir anahtar sözcük argümanı hakkında TypeError | Scrapy 2.13 veya daha eski | 2.14 veya üzerine yükseltin |
| RuntimeError: Task got bad yield | Bir coroutine içinde doğrudan await edilen bir Deferred | asyncio.to_thread ya da maybe_deferred_to_future kullanın |
| 403 sayfaları HttpErrorMiddleware’e ulaşır ve hiçbir görev gönderilmez | Middleware numarası 590’ın üzerinde ya da engelleme sayfası ne bir iframe adresi ne de bir dd nesnesi içeriyor | 551 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ür | Cookie’ler kapalı, bir Cookie başlığı ya da değiştirilmiş bir User-Agent | Yeniden denemeyi kimlikle karşılaştırın |
| Günlükte ERROR_PROXY_BANNED veya ERROR_PROXY_CONNECT_REFUSED | CapSkip adresi yasaklı ya da ulaşılamaz olarak bildiriyor | O jar için proxy’yi değiştirin |
Günlükte ValidationException, mesajında t=bv geçiyor | Engelleme sayfası adresin yasaklı olduğunu söylüyor | O jar için proxy’yi değiştirin |
| Günlükte NetworkException | settings.py içindeki host ve portta hiçbir şey yanıt vermiyor | CapSkip’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.
