So lösen Sie DataDome CAPTCHA in Node.js mit fetch

Um ein DataDome CAPTCHA in Node.js zu lösen, lesen Sie die 403-Sperrseite, bauen daraus die Challenge-Adresse und senden diese Adresse an den CapSkip-Solver für DataDome mit dataDome() und wiederholen Ihre Anfrage mit dem zurückgegebenen Cookie. Die Antwort ist ein Cookie und kein Token für ein Formular, und laut der CapSkip-Dokumentation funktioniert es meist nur mit dem User-Agent und der IP-Adresse, mit denen es ausgestellt wurde. Dieser Leitfaden führt die ganze Schleife mit dem CapSkip-SDK für Node.js und fetch in etwa 100 Zeilen aus. CapSkip läuft auf Ihrem eigenen Windows-PC ohne Gebühr pro Lösung, daher fällt auch bei einer Wiederholung keine Lösungsgebühr an.

Was Sie brauchen

• CapSkip 3.2.0 oder neuer, das auf einem Windows-PC läuft. Mit dieser Version kam das Lösen von DataDome für den Slider und die Geräteprüfung dazu. Die Einrichtungsanleitung führt durch den ersten Start.
• Node.js und das Paket capskip ab Version 1.5.0. Frühere Versionen haben keine Methode dataDome. Das Paket deklariert Node.js 18 oder neuer. Ich habe den Code nur auf Node.js 24.22.0 ausgeführt, mit capskip 1.5.0 und undici 8.12.3, daher ist Node.js 18 hier nicht getestet. Das Paket undici 8 deklariert Node.js 22.19 oder neuer. Nach den in engines deklarierten Versionen braucht undici 7 Node.js 20.18.1 oder neuer und undici 6 braucht Node.js 18.17 oder neuer, ein älteres Node.js braucht also ein älteres undici. Keines von beiden habe ich ausgeführt.
• Eine Eingabeaufforderung, in der node und npm funktionieren.
• Eine Seite, die Ihnen gehört oder die Sie automatisieren dürfen, hinter DataDome.
• Eine Adresse für den Solver. Im Local-Modus antwortet CapSkip auf 127.0.0.1 nur für dieses Gerät. Im Server-Modus lauscht es auf Ihrer Netzwerkadresse oder öffentlichen IP, damit ein Skript auf einem anderen PC, einem VPS oder einer gehosteten Plattform es über die API aufrufen kann. Eingestellt werden beide Modi in den Verbindungseinstellungen.
• Ein Sticky-Proxy (ein Proxy, der dieselbe IP-Adresse behält) pro Aufgabe, sobald Sie über das Testen hinausgehen. Das Cookie ist an die IP-Adresse gebunden, mit der es ausgestellt wurde, was Schritt 3 erklärt.

Installieren Sie die beiden Pakete mit npm install capskip undici. Node.js bringt fetch mit, aber es hat keine Proxy-Option pro Anfrage. Das Paket undici ergänzt eine mit ProxyAgent, daher importiert der Code fetch ebenfalls aus undici. Als ich einen ProxyAgent aus undici 8.12.3 an das in Node.js 24.22.0 eingebaute fetch übergab, schlug das bei mir mit dem Fehler fetch failed fehl, dessen Ursache invalid onRequestStart method lautet (Fehlercode UND_ERR_INVALID_ARG), weil dieses Node.js undici 7.29.1 mitbringt. Wenn Sie beides aus einem Paket nehmen, vermeiden Sie die Unstimmigkeit.

So wurde getestet: Der Code lief gegen drei Mock-Server, die ich geschrieben habe, nicht gegen eine echte DataDome-Website. Einer bildet die Prüfungen nach, die im DataDome-Abschnitt der CapSkip API-Dokumentation, ein zweiter spielt eine geschützte Website, die eine 403-Sperrseite ausliefert und nur ein Cookie akzeptiert, das CapSkip ausgestellt hat, mit dem User-Agent, für den es ausgestellt wurde, und ein dritter spielt einen Forward-Proxy. Das SDK war das echte capskip 1.5.0. Die CapSkip-App lief auf meinem PC, aber jedes Skript zeigte auf die Mocks, daher hat die App nichts gelöst. Nichts hier zeigt, wie lange eine echte Lösung dauert oder was eine echte DataDome-Website akzeptiert. Das Auslesen der Sperrseite wurde nur an Seiten ausprobiert, die das Format aus der CapSkip-Dokumentation nachbilden. Der Proxy-Pfad wurde mit einem http-Proxy getestet, der einfache Anfragen an eine http-Website weiterleitet. Der Tunnel, den eine https-Website über einen Proxy braucht, wurde nicht getestet, ebenso wenig ein https-Proxy. Die Regeln zum Cookie stammen aus der CapSkip-Dokumentation. Die eigene Cookie-Dokumentation von DataDome sagt, dass das Cookie datadome ein Jahr gültig ist, und warnt davor, seine Domain oder seinen Path zu ändern. Woran das Cookie gebunden ist, sagt sie nicht.

Schritt 1: Die Sperrseite lesen und die captcha_url bauen

Legen Sie diesen Block und die nächsten drei in einer Datei namens datadome-demo.js ab, in der gezeigten Reihenfolge. Bis Schritt 4 läuft nichts.

Wenn DataDome an einer Anfrage zweifelt, antwortet die Website statt mit dem Inhalt mit dem Status 403, manchmal 401, und einer kleinen HTML-Seite. Diese Seite enthält ein Skript-Objekt namens dd und lädt die Challenge in einem iframe von geo.captcha-delivery.com. Die Adresse des iframe braucht CapSkip, und die Dokumentation nennt sie captchaUrl. Enthält die Seite den iframe bereits, können Sie dessen src unverändert übernehmen. Die meisten Sperrseiten bauen den iframe stattdessen per Skript, daher setzt die Funktion unten dieselbe Adresse aus dem Objekt dd zusammen.

Der Wert von rt bestimmt den Pfad. Der Buchstabe c steht für den Slider unter /captcha/, der Buchstabe i für die Geräteprüfung unter /interstitial/. Auch der Wert t zählt: Der Wert fe kennzeichnet eine Challenge, und der Wert bv bedeutet, dass DataDome die IP-Adresse gesperrt hat, die die Seite abgerufen hat. Die erste Anfrage geht mit einem einfachen Chrome-User-Agent hinaus. Diese Zeichenfolge wird nie an CapSkip gesendet, daher muss ihre Chrome-Version zu nichts passen. Ich habe nicht getestet, ob eine echte DataDome-Website einem anderen User-Agent dieselbe Challenge ausliefert, betrachten Sie diesen Teil also als ungetestet.

Die Funktion get liest den ganzen Body, bevor sie zurückkehrt, daher bleibt keine Verbindung offen und wartet. Übergeben Sie ihr eine Proxy-Adresse, sendet sie die Anfrage über den ProxyAgent von undici, der einen http- oder https-Proxy akzeptiert. Einen SOCKS-Proxy habe ich nicht ausprobiert.

// npm install capskip undici
const { fetch, ProxyAgent } = require("undici");

const PAGE_URL = "https://www.example.com/"; // a page behind DataDome
const BROWSER = { // for the first request only; the cookie comes with its own User-Agent
  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
    + "(KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
};

const agents = new Map(); // one ProxyAgent per proxy, so sockets are reused

async function get(headers, proxyUrl) {
  const options = { headers };
  if (proxyUrl) {
    if (!agents.has(proxyUrl)) agents.set(proxyUrl, new ProxyAgent(proxyUrl));
    options.dispatcher = agents.get(proxyUrl);
  }
  const resp = await fetch(PAGE_URL, options);
  return { status: resp.status, text: await resp.text(), setCookies: resp.headers.getSetCookie() };
}

// Build the challenge address from a DataDome block page, or null.
function captchaUrlFrom(page) {
  if (![401, 403].includes(page.status)) return null;
  const found = page.text.match(/var\s+dd\s*=\s*(\{[^}]*\})/);
  if (!found) return null;
  const dd = JSON.parse(found[1].replace(/'/g, "\""));
  const path = dd.rt === "i" ? "interstitial" : "captcha";
  const query = new URLSearchParams({ initialCid: dd.cid, hash: dd.hsh, cid: dd.cookie });
  if (dd.t) query.set("t", dd.t); // fe is a challenge, bv means the address is banned
  query.set("referer", PAGE_URL);
  query.set("s", String(dd.s));
  for (const key of ["e", "b"]) {
    if (dd[key]) query.set(key, String(dd[key]));
  }
  query.set("dm", "cd");
  return `https://${dd.host || "geo.captcha-delivery.com"}/${path}/?${query}`;
}

Die Funktion gibt null für jede Antwort zurück, die keine Sperrseite ist, sodass ein Skript “nichts zu lösen” von “gelöst” unterscheiden kann. Eine Seite, die nicht hinter DataDome liegt, etwa die Platzhalter-Adresse im Code, gibt einfach 200 aus. Jede Sperrseite ist eine neue Challenge. Verwenden Sie die captchaUrl daraus bald, und rufen Sie die Seite für die nächste Aufgabe erneut ab, statt eine alte Adresse wiederzuverwenden.

Schritt 2: Mit dataDome() lösen

Die SDK-Methode lautet dataDome(captchaUrl, url, options) und folgt der Argumentreihenfolge von 2Captcha. Die ersten beiden sind Pflicht. In CapSkip sind userAgent und proxy optional und stehen im Objekt options. Senden Sie keinen User-Agent, verwendet CapSkip den aus seinem eigenen Browser und gibt ihn im Ergebnis als userAgent zurück. Senden Sie doch einen, muss es Chrome für Windows mit derselben Hauptversion wie im Browser von CapSkip sein, daher ist das Weglassen die einfache Wahl. Die Methode wartet mit dem längeren Timeout von 300 Sekunden, den auch reCAPTCHA verwendet, weil CapSkip die Challenge in einem echten Browser besteht. Laut der API-Dokumentation dauert eine Lösung meist 3 bis 20 Sekunden, und ich habe keine gemessen.

Der Proxy ist derjenige, den Ihre späteren Anfragen verwenden. Übergeben Sie ihn, wenn Ihr Skript über einen Proxy nach außen geht, und übergeben Sie nichts, wenn die Anfragen von dem Rechner ausgehen, auf dem CapSkip läuft. Bei einem CapSkip auf einem Server ist dieser Rechner der Server. Eine Option mit dem Wert undefined wird nicht gesendet, daher kann proxyOption für den Fall ohne Proxy undefined zurückgeben.

const { CapSkip } = require("capskip");

// Local mode. In Server mode, use your server's address instead.
const solver = new CapSkip({ host: "127.0.0.1", port: 8080 });

function proxyOption(proxyUrl) {
  if (!proxyUrl) return undefined; // your requests leave from the PC that runs CapSkip
  const [scheme, rest] = proxyUrl.split("://");
  return { type: scheme.toUpperCase(), uri: rest }; // e.g. HTTP, user:pass@ip:port
}

function solve(captchaUrl, proxyUrl) {
  // No userAgent option: CapSkip uses its own browser's and reports it.
  return solver.dataDome(captchaUrl, PAGE_URL, { proxy: proxyOption(proxyUrl) });
}

Lässt sich die Geräteprüfung nicht erfüllen, wechselt DataDome zu einem Slider. Laut der CapSkip-Dokumentation folgt der eine Aufruf dorthin, Sie brauchen also keinen getrennten Code für die beiden Challenges.

Schritt 3: Das Cookie mit seinem User-Agent und seiner IP-Adresse senden

Das Ergebnis ist ein Objekt mit vier wichtigen Feldern. Das Feld code ist das Cookie genau so, wie DataDome es gesetzt hat, mit Max-Age, Domain und den anderen Attributen, und genau das will ein Cookie-Jar. Das Feld cookie ist nur das Paar aus Name datadome und Wert, und genau das will ein Cookie-Header. Das Feld userAgent ist der User-Agent, mit dem es ausgestellt wurde. Ein Feld proxy erscheint nur, wenn Sie keinen Proxy gesendet haben und CapSkip über die eigene Proxy-Liste von CapSkip für DataDome gelöst hat. Laut der CapSkip-Dokumentation lehnt DataDome das Cookie meist von einer anderen IP-Adresse oder mit einem anderen User-Agent ab. Senden Sie also jedes Mal denselben User-Agent, und wenn das Ergebnis einen Proxy nennt, senden Sie die Anfrage darüber. Dieses Feld proxy besteht nur aus Host und Port, ohne Schema und ohne Login. Die Funktion setzt http:// davor und geht daher von einem Listen-Proxy ohne Login aus. Braucht Ihr Listen-Proxy einen, tragen Sie ihn selbst in die Adresse ein, etwa so: http://user:pass@ gefolgt von Host und Port.

DataDome kann bei einer späteren Antwort auch ein Ersatz-Cookie senden. Die Funktion liest die Zeilen von Set-Cookie und behält die neueste Zeile, wie es ein Browser täte.

async function sendWithCookie(result, proxyUrl) {
  // The cookie works only from the address and User-Agent that earned it.
  let via = proxyUrl;
  if (!via && result.proxy) {
    via = `http://${result.proxy}`; // CapSkip solved through its own list
  }
  const headers = { "User-Agent": result.userAgent, Cookie: result.cookie };
  const page = await get(headers, via);
  for (const line of page.setCookies) { // DataDome may rotate the cookie
    const fresh = line.match(/^datadome=([^;]+)/);
    if (fresh) headers.Cookie = `datadome=${fresh[1]}`;
  }
  return { page, headers, via };
}

Das Cookie wird von Hand im Header gesetzt, daher verwaltet nichts es für Sie. Das ist Absicht: So bleiben Cookie, User-Agent und Proxy an einer Stelle beisammen. Der Text nach dem Schema geht so an CapSkip, wie Sie ihn geschrieben haben, halten Sie den Proxy-Login also frei von Zeichen, die eine Prozentkodierung brauchen.

Schritt 4: Das vollständige funktionierende Beispiel

Der letzte Block fügt die Schritte zu einem Ablauf zusammen und ergänzt die Wiederholung. Fügen Sie ihn am Ende derselben Datei datadome-demo.js ein und führen Sie sie mit node datadome-demo.js aus. Jeder Versuch ruft die Seite erneut ab, daher trägt jeder Versuch eine frische Challenge. Eine fehlgeschlagene Lösung löst ApiException aus, und die Schleife versucht es erneut. Auch ein Cookie, das trotzdem eine 403 bekommt, schickt die Schleife mit der neuen Sperrseite noch einmal los. Eine Seite, die mit 403 antwortet, ohne eine DataDome-Sperrseite zu sein, beendet die Schleife mit einem Fehler, weil es nichts zu lösen gibt. Jede Wiederholung ruft eine weitere Sperrseite von der Website ab, halten Sie die Zahl der Versuche daher niedrig.

const { ApiException } = require("capskip");

const PROXY_URL = null; // e.g. "http://user:[email protected]:8080"; null means no proxy

async function fetchProtected(proxyUrl) {
  for (let attempt = 1; attempt <= 3; attempt += 1) {
    const block = await get(BROWSER, proxyUrl); // a fresh block page, a fresh challenge
    const captchaUrl = captchaUrlFrom(block);
    if (captchaUrl === null) {
      if (block.status >= 400) {
        throw new Error(`HTTP ${block.status} without a DataDome block page`);
      }
      return { page: block, headers: BROWSER, via: proxyUrl }; // no block page here
    }
    let result;
    try {
      result = await solve(captchaUrl, proxyUrl);
    } catch (err) {
      if (!(err instanceof ApiException)) throw err;
      if (err.message.includes("ERROR_PROXY_")) throw err; // the address is the problem
      console.log(`attempt ${attempt}: ${err.message}`); // the next attempt gets a new page
      continue;
    }
    const sent = await sendWithCookie(result, proxyUrl);
    if (sent.page.status !== 200) {
      console.log(`attempt ${attempt}: HTTP ${sent.page.status} with the cookie`);
      continue;
    }
    return sent;
  }
  throw new Error("DataDome not passed in 3 attempts");
}

async function main() {
  const { page, headers, via } = await fetchProtected(PROXY_URL);
  console.log(page.status, page.text.slice(0, 40));
  const again = await get(headers, via); // reuse the cookie while it lasts
  console.log(again.status);
}

main().catch((err) => {
  console.error(`${err.name}: ${err.message}`);
  process.exitCode = 1;
});

Das SDK weist eine captchaUrl mit t=bv ab, bevor etwas gesendet wird, weil keine Lösung von dieser Adresse aus bestehen kann. Diese ValidationException ist keine ApiException, daher wirft die Schleife sie erneut, statt es noch einmal zu versuchen. Lassen Sie sie durchlaufen: Sie ist das Signal, die IP-Adresse zu wechseln und von vorn zu beginnen. Die Schleife wirft auch die zwei Fehler erneut, die die IP-Adresse nennen, ERROR_PROXY_BANNED und ERROR_PROXY_CONNECT_REFUSED, weil laut der CapSkip-Dokumentation ein erneutes Senden über dieselbe IP-Adresse wieder scheitern würde. Die Meldung der ApiException ist der Text der Antwort der App, daher gleicht die Schleife sie mit includes() ab und nicht mit einem exakten Vergleich. Sehen Sie einen dieser Fehler, wechseln Sie den Proxy, bevor Sie erneut starten. Rotierende Proxys behandelt der Leitfaden zur Proxy-Rotation.

Im Mock-Lauf verhielt sich das Skript auf Node.js 24.22.0 so:

Die letzten zwei Zeilen testen die Regeln meines Mocks, die der CapSkip-Dokumentation folgen. Sie sind kein Beleg für den echten Dienst.

Häufige Fehler

Den Löser auf einem Server betreiben

Das Skript für ein DataDome CAPTCHA in Node.js braucht von CapSkip zwei Dinge: einen Host und einen Port. Im Local-Modus sind das 127.0.0.1 und Ihr eigener PC. Im Server-Modus lauscht CapSkip auf Ihrer Netzwerkadresse oder einer öffentlichen IP, sodass ein Skript auf einem anderen PC, einem VPS oder einer gehosteten Plattform es über dieselbe API aufrufen kann. Ändern Sie Host und Port im Konstruktor CapSkip. Eine statische öffentliche IP wird für stabilen Fernzugriff empfohlen. Der Server-Modus bleibt Ihre eigene Hardware, und es fallen weiterhin keine Gebühren pro Lösung an. Er öffnet den Port allerdings für jede Adresse, fügen Sie daher eine Blockierregel der Windows Firewall für die Adressen hinzu, die ihn nicht erreichen sollen. Eine Sache ändert sich jedoch: Die Lösung läuft auf diesem Rechner, das Cookie wird also von der IP-Adresse des Servers ausgestellt. Wenn Sie keinen Proxy übergeben, muss auch die Anfrage, die das Cookie trägt, von diesem Server ausgehen. Mit einem Proxy übergeben Sie denselben an die Lösung und an Ihre Anfragen. Die Verbindungseinstellungen zeigen, wie Sie den Modus wechseln.

FAQ

Die Kurzfassung

Ein DataDome CAPTCHA in Node.js besteht aus vier Schritten: die Sperrseite lesen, die captchaUrl bauen, dataDome() aufrufen und die Anfrage mit dem Cookie sowie dem User-Agent und der IP-Adresse wiederholen, zu denen es gehört. Lösungen kosten auf Ihrem eigenen Rechner nichts, und genau dafür ist ein unbegrenzter Captcha-Löser da, wenn eine geschützte Website Ihnen immer wieder frische Challenges liefert. Beachten Sie aber, dass jede Wiederholung eine weitere Sperrseite abruft, halten Sie die Zahl der Versuche also niedrig. Für den Rest des SDK siehe die Node.js-Captcha-Solver-Seite. Denselben Ablauf in Python finden Sie im Python-DataDome-Leitfaden.