Как решить блокировки 403 DataDome в Scrapy с помощью middleware

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

Чтобы справиться с DataDome в Scrapy, поместите всю работу в один downloader middleware. Он замечает страницу блокировки 403, получает у CapSkip cookie datadome методом datadome из Python SDK и повторяет запрос с этим cookie, его User-Agent и тем же прокси. Успех DataDome в Scrapy держится на номере приоритета, фильтре дублей, блокирующем вызове SDK и отдельном cookie jar на каждый прокси. Это руководство подключает решатель CapSkip для DataDome к проекту Scrapy и сообщает, что дал каждый выбор в моих запусках.

Что понадобится

  • ПК с Windows и CapSkip 3.2.0 или новее, первым выпуском с DataDome. Подробное руководство по настройке расскажет, как установить CapSkip и запустить его.
  • Python 3.11 или новее: этого требуют Scrapy 2.20, w3lib и itemadapter.
  • Scrapy 2.14 или новее. В 2.13.4 middleware падает с TypeError, потому что этот выпуск всё ещё передаёт "spider" в каждый метод middleware.
  • capskip 1.5.0 или новее, первая версия с методом datadome.
  • Адрес, по которому отвечает CapSkip: 127.0.0.1 в Local mode, доступный только с этого же ПК, либо ваш сетевой или публичный IP в Server mode.
  • Один постоянный (sticky) прокси на каждую идентичность обхода, в виде полного URL, например http://user:[email protected]:8080. Прокси, который меняет выходной IP при каждом соединении, не может дать рабочий cookie, говорится в документации CapSkip.

В командной строке PowerShell создайте проект, в который пойдут все блоки ниже. Имена файлов указаны относительно папки, в которой лежит scrapy.cfg, а блок, с которого начинается файл, заменяет сгенерированный.

pip install scrapy capskip
scrapy startproject shop
cd shop

Я тестировал на имитациях серверов, которые написал сам, а не на настоящем сайте с DataDome и не на приложении CapSkip. Одна копирует проверки in.php и res.php из документации API CapSkip. Другая отвечает 403, если в запросе нет cookie, выданного первой, для того User-Agent и прокси, для которых он был выдан; эти правила привязки взяты из документации CapSkip, а не из DataDome. Я запускал Python 3.11.7 и 3.14.0. Если не сказано иное, числа получены на Scrapy 2.20.0 и capskip 1.7.0 при DOWNLOAD_DELAY равном 0 и имитации, которая решает за 0.4 секунды, и совпали на обоих Python. Scrapy 2.14.0 с capskip 1.5.0 и Scrapy 2.19.0 с capskip 1.6.0 в нескольких случаях дали те же числа.

Пишем middleware для DataDome в Scrapy

Шаг 1: выберите номер приоритета

Scrapy вызывает process_request в порядке возрастания номеров, а process_response в порядке убывания, поэтому больший номер стоит ближе к загрузчику. HttpCompressionMiddleware на 590 распаковывает тело, поэтому наш номер должен быть ниже 590, чтобы прочитать страницу блокировки. RetryMiddleware на 550 превращает ответы в повторы, поэтому наш должен быть выше, чтобы видеть их первым. Остаётся диапазон от 551 до 589, а поскольку 580 занят MetaRefreshMiddleware, в настройках стоит 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 страница блокировки доходила до middleware как байты 1f 8b, и 403 проходил дальше; при 570 она решалась. Если 403 входит в RETRY_HTTP_CODES, имитация сайта отдала 3 страницы блокировки до решения при 540 и одну при 570.

Шаг 2: распознайте страницу блокировки

Блокировка DataDome приходит со статусом 401 или 403. Если её страница уже содержит iframe с проверкой, код берёт этот адрес как есть, как сказано в документации CapSkip. В противном случае он собирает captcha_url из объекта скрипта dd, где значение rt выбирает путь: /interstitial/ для проверки устройства и /captcha/ для слайдера. В таблице документации параметр t указан только для /captcha/, но собственный JavaScript из документации задаёт его безусловно, и я следовал JavaScript. Всё нечитаемое возвращает None, поэтому обычный 403 проходит нетронутым. Девять ответов, собранных вручную, покрыли каждый случай, а имитация проверки устройства дала 1 задание на 2 страницы. Структура взята из документации CapSkip, а не с живой страницы.

# 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

Cookie хранится в jar, который выбирает ключ cookiejar в meta, поэтому middleware держит одну идентичность на каждый jar: cookie, его User-Agent, прокси, если его выбрал CapSkip, и номер поколения, который растёт с каждым решением. Без строки с User-Agent повторный запрос уходил со стандартным User-Agent Scrapy, и четыре прямые страницы заканчивались 3 заданиями и ни одной страницей.

Cookie передаётся через аргумент "cookies", который CookiesMiddleware на 700 копирует в jar. Он добавляется лишь до тех пор, пока не вернётся один запрос с ним, поэтому заменяющий cookie от сайта не перезаписывается. Имитация присылает такой, и страница, загруженная позже, несла его без нового задания. Заголовок Cookie не работает, потому что CookiesMiddleware пересобирает заголовок из jar, и отключение cookie тоже не помогает. Оба варианта закончились 3 заданиями и ни одной страницей.

Атрибуты "Domain" и "Path" берутся из поля "code" результата, где cookie лежит в том виде, в каком его выставил DataDome, поэтому cookie для сайта с именем сохраняет свой домен. Для страниц на 127.0.0.1 имитация выдала 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: решите в потоке, затем повторите запрос

Метод datadome в CapSkip блокирует вызов, пока опрашивает результат. Если вызвать его прямо из корутины, он удерживает реактор, поэтому middleware передаёт его в asyncio.to_thread. В SDK есть и AsyncCapSkip, у которого метод datadome можно вызывать через await. Повторный запрос задаёт dont_filter, потому что его URL уже прошёл фильтр дублей. Без этого dupefilter отбросил оба повтора, и 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)

Это расширение срабатывает каждые 50 миллисекунд и записывает самый длинный промежуток. В обходе была одна заблокированная страница, 30 открытых страниц и 8 одновременных запросов, имитация отвечала 3 секунды, менялся только вызов решения. Каждая строка показывает диапазон не менее чем трёх запусков на каждом 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Самый длинный промежуток между тиками на одном ПК
Прямой вызов внутри корутиныпримерно от 3770 до 3840 мс
asyncio.to_thread, код вышепримерно от 65 до 75 мс
AsyncCapSkip с await в корутинепримерно от 220 до 530 мс
deferToThread с maybe_deferred_to_futureпримерно от 65 до 90 мс
deferToThread с await без преобразованияпримерно от 65 до 80 мс, запрос потерян

AsyncCapSkip, который я запускал по шесть раз на каждом Python, работает, но подвисает дольше: каждый вызов CapSkip создаёт нового клиента httpx, а создание одного заняло на этом ПК от 130 до 190 мс. Последняя строка выглядит правильно, но это не так: она вызвала RuntimeError, Task got bad yield, и запрос был потерян. Весь middleware к тому же требует реактор asyncio, который в Scrapy 2.20.0 используется по умолчанию. Под классическим реактором select он вызвал RuntimeError и не отправил ни одного задания.

Шаг 5: решите, что делает каждый заблокированный ответ

Запросы в одном jar блокируются вместе, и каждый запустил бы своё решение. Первый заблокированный ответ запускает его и сохраняет в self.solving, а остальные запросы в этом jar ждут его. Восемь страниц через один прокси дали 1 задание с этим кодом и 8, когда каждый ответ решал сам за себя. Если задать CONCURRENT_REQUESTS_PER_DOMAIN равным 1, число страниц блокировки не уменьшилось: четыре страницы, отправленные без прокси, всё равно собрали четыре страницы блокировки до того, как пришёл первый cookie.

DATADOME_MAX_SOLVES ограничивает два счётчика, и нужны оба. Запрос можно повторять столько раз (dd_tries). Каждая пара из домена и cookie jar может запустить столько решений между страницами, которые прошли (self.spent). При ключе только по домену пять jar, каждый из которых одновременно загрузил по одной странице (разрешено 16 запросов на домен), получили 3 задания и потеряли 2 страницы. При ключе по домену и jar они получили 5 заданий и 5 страниц. URL, который отвергает каждый cookie, среди 60 хороших страниц постоянно сбрасывал бюджет, и остановил его только счётчик на запрос, на 3 заданиях. Поскольку CapSkip представляет собой безлимитный сервис распознавания капчи по фиксированной лицензии, лимиты защищают от зацикливания, а не от трат.

    # 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: один cookie jar на каждый прокси

Обход через несколько прокси требует отдельного jar на каждый прокси, чтобы у каждой идентичности был один адрес, и паук называет каждый jar по его прокси. Scrapy не переносит ни один из этих ключей в запросы, которые вы строите из ответа: ссылка, по которой перешли через response.follow и без meta, ушла напрямую через jar по умолчанию, была заблокирована и решалась снова. Скопируйте ключи proxy и cookiejar в каждый запрос, который вы создаёте.

Другая ошибка: один jar на два прокси. Восемь страниц, разделённых между ними, закончились 12 страницами блокировки вместо 8 во всех трёх запусках на каждом Python, при одном запросе за раз и задержке 0.2 секунды. Обе схемы дали 2 задания.

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

Оба списка содержат заглушки; для своего запуска я подставил свои имитации прокси и страниц и больше ничего не менял. При задержке 1 из шаблона вышло 2 задания, и загрузились все 8 страниц. Scrapy переносит логин прокси в заголовок до того, как приходит ответ, поэтому middleware хранит прокси в том виде, как он записан; без этого моя имитация получала задание без логина.

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

Когда CapSkip решает через собственный список прокси, результат называет этот прокси, и идентичность его сохраняет, потому что cookie работает только через него. В документации сказано, что он возвращается без логина, поэтому прокси из списка с логином не проверялся.

Ошибки 403 от DataDome, которые могут встретиться в Scrapy

Каждую строку я вызвал намеренно в запуске на имитации, кроме отсутствующего dd объекта и страницы только с iframe: их покрыли лишь ответы, собранные вручную. Отклонённое задание записывается в лог, и страница запрашивается снова. Отказ, который называет адрес, ERROR_PROXY_BANNED или ERROR_PROXY_CONNECT_REFUSED, записывается в лог и передаётся дальше, потому что в документации сказано: повтор через этот адрес снова не удастся. Моя имитация вернула оба на этапе получения результата, а на настоящем приложении я их не вызывал. Любая другая ошибка SDK записывается в лог и передаётся дальше.

Что вы видитеПричинаИсправить
TypeError про неожиданный аргумент "spider"Scrapy 2.13 или старшеОбновитесь до 2.14 или новее
RuntimeError: Task got bad yieldDeferred, ожидаемый через await прямо в корутинеИспользуйте asyncio.to_thread или maybe_deferred_to_future
Страницы 403 доходят до HttpErrorMiddleware, и задание не отправляетсяНомер middleware выше 590, либо в странице блокировки нет ни адреса iframe, ни dd в виде объектаИспользуйте от 551 до 589 и поищите в странице блокировки любой из двух вариантов
Страницы остаются заблокированными, а в статистике появляется счётчик budget_used_upCookie отключены, заголовок Cookie или изменённый User-AgentСравните повтор с идентичностью
ERROR_PROXY_BANNED или ERROR_PROXY_CONNECT_REFUSED в логеCapSkip называет адрес забаненным или недоступнымСмените прокси для этого jar
ValidationException с t=bv в логеСтраница блокировки сообщает, что адрес забаненСмените прокси для этого jar
NetworkException в логеПо хосту и порту из settings.py никто не отвечаетЗапустите CapSkip и проверьте и то и другое

Правила порядка описывает справка по downloader middleware проекта Scrapy, а ту же идею для reCAPTCHA разбирает руководство по middleware для капчи в Scrapy, и о масштабном сборе данных рассказывает страница о веб-скрейпинге.

Запуск CapSkip на сервере

Server mode заставляет CapSkip отвечать по адресу вашей сети или по публичному IP, поэтому краулер на другом ПК или на Windows VPS сможет до него дотянуться. Включите его в разделе Настройки подключения программы CapSkip и укажите адрес этой машины в DATADOME_CAPSKIP_HOST; больше ничего не меняется. Запуск Server mode оставляет порт CapSkip открытым для всех адресов, поэтому добавьте правило брандмауэра Windows, которое блокирует машины, которым доступ не нужен. Решение выполняется на сервере, поэтому cookie получается с его адреса, если только запрос не несёт прокси, который middleware передаёт дальше. Я ничего из этого не запускал, только имитацию на 127.0.0.1, а при включённой API Key Validation вы передали бы apiKey в конструктор CapSkip.

FAQ

Можно ли вместо потока вызывать AsyncCapSkip через await?

Да. Создайте AsyncCapSkip вместо CapSkip и вызывайте его метод datadome через await в self.solve. Он дал те же числа, что и поток, на обоих Python, но с более долгой паузой, от 220 до 530 мс на моём ПК.

Сколько решений понадобится реальному обходу Scrapy с DataDome?

Не могу сказать. На имитации выходило одно решение на прокси, потому что имитация никогда не истекает cookie. Ключ статистики datadome/solves считает решения в вашем собственном обходе.