Node.js में fetch से DataDome कैप्चा कैसे हल करें

Node.js में DataDome कैप्चा हल करने के लिए आप 403 ब्लॉक पेज पढ़ते हैं, उससे चैलेंज का पता बनाते हैं, और उसे CapSkip DataDome सॉल्वर को dataDome() के साथ भेजते हैं, फिर मिली cookie के साथ अपनी रिक्वेस्ट दोहराते हैं। जवाब एक cookie है, फ़ॉर्म के लिए कोई टोकन नहीं, और CapSkip के दस्तावेज़ कहते हैं कि वह आम तौर पर सिर्फ़ उसी User-Agent और उसी IP पते के साथ काम करती है जिसके साथ वह मिली थी। यह गाइड CapSkip Node.js SDK और fetch के साथ पूरा loop करीब 100 लाइनों में चलाती है। CapSkip आपके अपने Windows PC पर चलता है और प्रति-हल कोई शुल्क नहीं लगता, इसलिए दोबारा कोशिश करने पर भी कोई हल शुल्क नहीं लगता।

आपको क्या चाहिए

• CapSkip 3.2.0 या बाद का, जो किसी Windows PC पर चल रहा हो। उस रिलीज़ में स्लाइडर और डिवाइस चेक के लिए DataDome हल करने की सुविधा जुड़ी थी। पहली बार शुरू करने के चरण सेटअप गाइड में समझाए गए हैं।
• Node.js और capskip पैकेज का वर्ज़न 1.5.0 या बाद का। पुराने वर्ज़न में dataDome method नहीं है। पैकेज Node.js 18 या बाद का घोषित करता है। मैंने कोड सिर्फ़ Node.js 24.22.0 पर चलाया, capskip 1.5.0 और undici 8.12.3 के साथ, इसलिए Node.js 18 यहाँ आज़माया नहीं गया। undici 8 पैकेज Node.js 22.19 या बाद का घोषित करता है। उनके घोषित engines के अनुसार undici 7 को Node.js 20.18.1 या बाद का चाहिए और undici 6 को Node.js 18.17 या बाद का, इसलिए पुराने Node.js के लिए पुराना undici चाहिए। मैंने इनमें से कोई नहीं चलाया।
• एक command prompt जहाँ node और npm काम करते हों।
• ऐसा पेज जो आपका अपना हो या जिसे ऑटोमेट करने की आपको अनुमति हो, और जो DataDome के पीछे हो।
• सॉल्वर के लिए एक पता। Local मोड में CapSkip केवल उसी डिवाइस के लिए 127.0.0.1 पर जवाब देता है। Server मोड में वह आपके नेटवर्क पते या पब्लिक IP पर सुनता है, ताकि किसी दूसरे PC, VPS या होस्टेड प्लेटफ़ॉर्म पर चल रही script API के ज़रिए उसे कॉल कर सके। दोनों यहाँ सेट किए जाते हैं: कनेक्शन सेटिंग्स.
• टेस्टिंग से आगे बढ़ने पर हर टास्क के लिए एक sticky proxy (जो पूरे टास्क में एक ही IP पता बनाए रखे)। cookie उस IP पते से बँधी होती है जिससे वह मिली थी, जिसे चरण 3 समझाता है।

दोनों पैकेज npm install capskip undici से इंस्टॉल करें। Node.js के साथ fetch आता है, पर उसमें हर रिक्वेस्ट के लिए proxy का option नहीं है। undici पैकेज ProxyAgent से वह जोड़ देता है, इसलिए कोड fetch को भी undici से import करता है। undici 8.12.3 का ProxyAgent Node.js 24.22.0 में बने fetch को देने पर मेरे setup में fetch failed error आया, जिसका cause invalid onRequestStart method है (error code UND_ERR_INVALID_ARG), क्योंकि वह Node.js अपने साथ undici 7.29.1 बंडल करता है। दोनों को एक ही पैकेज से लेने पर यह बेमेल नहीं होता।

यह कैसे टेस्ट किया गया: कोड तीन mock सर्वर के सामने चला जो मैंने खुद लिखे थे (यानी टेस्ट के लिए बनाए नकली सर्वर), किसी असली DataDome साइट के सामने नहीं। उनमें से एक उन जाँचों की नक़ल करता है जो CapSkip के API दस्तावेज़ के DataDome सेक्शन में सूचीबद्ध हैं, दूसरा एक संरक्षित साइट की भूमिका निभाता है जो 403 ब्लॉक पेज देती है और सिर्फ़ वही cookie स्वीकार करती है जो CapSkip ने जारी की हो, उसी User-Agent के साथ जिसके लिए वह जारी हुई थी, और तीसरा forward proxy की भूमिका निभाता है। SDK असली capskip 1.5.0 था। CapSkip app मेरे PC पर चल रहा था, पर हर script mock की ओर इशारा करती थी, इसलिए app ने कुछ हल नहीं किया। यहाँ कुछ नहीं दिखाता कि असली हल में कितना समय लगता है या कोई असली DataDome साइट क्या स्वीकार करती है। ब्लॉक पेज की पार्सिंग सिर्फ़ उन पेजों पर आज़माई गई जो CapSkip के दस्तावेज़ों के फ़ॉर्मैट की नक़ल करते हैं। proxy वाला रास्ता एक http proxy से परखा गया जो सादी रिक्वेस्ट को http साइट तक पहुँचाता है। https साइट को proxy के ज़रिए जो tunnel चाहिए, वह परखा नहीं गया, और https proxy भी नहीं। cookie के नियम CapSkip के दस्तावेज़ों से आते हैं। DataDome के अपने cookie दस्तावेज़ के अनुसार datadome cookie एक साल चलती है, और उसके Domain या Path को बदलने से आगाह किया गया है। यह नहीं बताया गया कि cookie किससे बँधी है।

चरण 1: ब्लॉक पेज पढ़ें और captcha_url बनाएँ

इस ब्लॉक और अगले तीन ब्लॉक को दिखाए गए क्रम में datadome-demo.js नाम की एक फ़ाइल में रखें। चरण 4 तक कुछ नहीं चलता।

जब DataDome को किसी रिक्वेस्ट पर शक होता है, तो साइट कंटेंट की जगह status 403, कभी-कभी 401, और एक छोटा HTML पेज लौटाती है। उस पेज में dd नाम का एक script object होता है और वह geo.captcha-delivery.com से एक iframe में चैलेंज लोड करता है। CapSkip को iframe का वही पता चाहिए, और दस्तावेज़ उसे captchaUrl कहते हैं। अगर पेज में iframe पहले से मौजूद है, तो आप उसका src जैसा है वैसा ले सकते हैं। ज़्यादातर ब्लॉक पेज iframe को script से बनाते हैं, इसलिए नीचे की function dd object से वही पता जोड़कर बनाती है।

rt की value रास्ता तय करती है। अक्षर c का मतलब /captcha/ के नीचे का स्लाइडर है और अक्षर i का मतलब /interstitial/ के नीचे का डिवाइस चेक। t की value भी मायने रखती है: value fe एक चैलेंज बताती है, और value bv का मतलब है कि पेज लाने वाले IP पते को DataDome ने बैन कर दिया है। पहली रिक्वेस्ट सादे Chrome User-Agent के साथ जाती है। वह string कभी CapSkip को नहीं भेजी जाती, इसलिए उसके Chrome वर्ज़न का किसी चीज़ से मेल खाना ज़रूरी नहीं। मैंने यह नहीं आज़माया कि कोई असली DataDome साइट किसी दूसरे User-Agent को वही चैलेंज देती है या नहीं, इसलिए इस हिस्से को बिना परखा हुआ मानें।

get function लौटने से पहले पूरी body पढ़ लेती है, इसलिए कोई connection इंतज़ार में अटका नहीं रहता। उसे proxy का पता दें तो वह रिक्वेस्ट को undici के ProxyAgent से भेजती है, जो http या https proxy स्वीकार करता है। मैंने SOCKS proxy नहीं आज़माया।

// 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}`;
}

function हर उस response के लिए null लौटाती है जो ब्लॉक पेज नहीं है, ताकि script “हल करने को कुछ नहीं” और “हल हो गया” में फ़र्क़ कर सके। जो पेज DataDome के पीछे नहीं है, जैसे कोड का placeholder पता, वह बस 200 प्रिंट करता है। हर ब्लॉक पेज एक नया चैलेंज होता है। उसके captchaUrl का जल्दी इस्तेमाल करें, और अगले टास्क के लिए पुराने पते को दोबारा इस्तेमाल करने के बजाय पेज फिर से रिक्वेस्ट करें।

चरण 2: dataDome() से हल करें

SDK का method dataDome(captchaUrl, url, options) है, जो 2Captcha के argument क्रम का पालन करता है। पहले दो ज़रूरी हैं। CapSkip में userAgent और proxy वैकल्पिक हैं और options object में जाते हैं। अगर आप कोई User-Agent नहीं भेजते, तो CapSkip अपने ब्राउज़र वाला इस्तेमाल करता है और उसे नतीजे में userAgent के रूप में लौटाता है। अगर आप भेजते हैं, तो वह CapSkip के ब्राउज़र के ही major वर्ज़न वाला Windows के लिए Chrome होना चाहिए, इसलिए उसे छोड़ देना आसान चुनाव है। method 300 सेकंड के उस लंबे timeout के साथ इंतज़ार करता है जो reCAPTCHA इस्तेमाल करता है, क्योंकि CapSkip चैलेंज को असली ब्राउज़र में पास करता है। API दस्तावेज़ कहते हैं कि एक हल में आम तौर पर 3 से 20 सेकंड लगते हैं, और मैंने किसी का समय नहीं नापा।

proxy वही है जिससे आपकी बाद की रिक्वेस्ट जाएँगी। अगर आपकी script proxy से होकर जाती है तो उसे दें, और अगर रिक्वेस्ट उसी मशीन से निकलती हैं जिस पर CapSkip चलता है तो कुछ न दें। अगर CapSkip किसी server पर चल रहा है, तो वह मशीन वही server है। जो option undefined छोड़ा जाए वह भेजा नहीं जाता, इसलिए बिना proxy वाली स्थिति में proxyOption undefined लौटा सकता है।

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) });
}

अगर डिवाइस चेक पास नहीं हो पाता, तो DataDome स्लाइडर पर चला जाता है। CapSkip के दस्तावेज़ों के अनुसार वही एक call उसके पीछे वहाँ तक जाती है, इसलिए दोनों चैलेंज के लिए अलग कोड की ज़रूरत नहीं।

चरण 3: cookie को उसके User-Agent और IP पते के साथ भेजें

नतीजा एक object है जिसके चार फ़ील्ड मायने रखते हैं। code फ़ील्ड वह cookie है जैसी DataDome ने सेट की थी, Max-Age, Domain और बाकी attributes के साथ, और cookie jar को यही चाहिए। cookie फ़ील्ड सिर्फ़ datadome नाम और value की जोड़ी है, और Cookie header को यही चाहिए। userAgent फ़ील्ड वह User-Agent है जिसके साथ वह मिली थी। proxy फ़ील्ड तभी आता है जब आपने कोई proxy नहीं भेजा और CapSkip ने अपनी DataDome proxy list से हल किया। CapSkip के दस्तावेज़ कहते हैं कि DataDome आम तौर पर cookie को किसी दूसरे IP पते से या दूसरे User-Agent के साथ ठुकरा देता है, इसलिए हर बार वही User-Agent भेजें, और जब नतीजा किसी proxy का नाम दे, तो रिक्वेस्ट उसी से भेजें। वह proxy फ़ील्ड सिर्फ़ host और port है, बिना scheme और बिना login के। function http:// जोड़ देती है और इस तरह मान लेती है कि list proxy को login नहीं चाहिए। अगर आपकी list proxy को चाहिए, तो उसे खुद पते में रखें, जैसे http://user:pass@ और उसके बाद host और port।

DataDome बाद के किसी response में बदली हुई cookie भी भेज सकता है। function Set-Cookie की पंक्तियाँ पढ़ती है और सबसे नई वाली रखती है, जैसे ब्राउज़र रखता।

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 };
}

cookie को header में हाथ से सेट किया गया है, इसलिए कोई चीज़ उसे आपके लिए नहीं सँभालती। यह जान-बूझकर है: इससे cookie, User-Agent और proxy एक ही जगह साथ रहते हैं। scheme के बाद का text CapSkip को वैसे ही जाता है जैसा आपने लिखा, इसलिए proxy login में ऐसे अक्षर न रखें जिन्हें percent-encoding चाहिए।

चरण 4: पूरा काम करने वाला उदाहरण

आख़िरी ब्लॉक सभी चरणों को एक flow में जोड़ता है और retry भी जोड़ता है। इसे उसी datadome-demo.js फ़ाइल के अंत में सेव करें और node datadome-demo.js से चलाएँ। हर कोशिश पेज को दोबारा रिक्वेस्ट करती है, इसलिए हर बार नया चैलेंज साथ जाता है। नाकाम हल ApiException उठाता है और loop दोबारा कोशिश करता है। जिस cookie पर फिर भी 403 मिले, वह भी loop को नए ब्लॉक पेज के साथ दोबारा घुमा देती है। जो पेज DataDome के ब्लॉक पेज के बिना 403 दे, वह loop को error के साथ रोक देता है, क्योंकि हल करने को कुछ नहीं है। हर retry साइट से एक और ब्लॉक पेज लाती है, इसलिए कोशिशों की संख्या कम रखें।

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;
});

SDK t=bv वाले captchaUrl को कुछ भी भेजने से पहले ही ठुकरा देता है, क्योंकि उस पते से कोई हल पास नहीं हो सकता। वह ValidationException एक ApiException नहीं है, इसलिए loop उसे retry करने के बजाय फिर से उठा देता है। उसे सामने आने दें: यह संकेत है कि पता बदलकर फिर से शुरू करें। loop उन दो errors को भी फिर से उठाता है जो पते का नाम लेते हैं, यानी ERROR_PROXY_BANNED और ERROR_PROXY_CONNECT_REFUSED, क्योंकि CapSkip के दस्तावेज़ कहते हैं कि उसी पते से दोबारा भेजने पर वही नाकामी होगी। ApiException का संदेश app के जवाब का text है, इसलिए loop उसे includes() से मिलाता है, पूरे मिलान से नहीं। इनमें से कोई error दिखे, तो दोबारा चलाने से पहले proxy बदलें। proxies को बारी-बारी से बदलने के बारे में देखें: proxy rotation गाइड.

Node.js 24.22.0 पर mock रन में script ने इस तरह व्यवहार किया:

आख़िरी दो पंक्तियाँ मेरे mock के नियमों को जाँचती हैं, जो CapSkip के दस्तावेज़ों का पालन करते हैं। ये असली service के बारे में कोई सबूत नहीं हैं।

आम errors

सॉल्वर को किसी server पर चलाना

Node.js में DataDome कैप्चा के लिए script को CapSkip से दो चीज़ें चाहिए: एक host और एक port। Local mode में वह 127.0.0.1 और आपका अपना PC है। Server mode में CapSkip आपके नेटवर्क पते या पब्लिक IP पर सुनता है, ताकि किसी दूसरे PC, VPS या hosted platform पर चल रही script उसी API के ज़रिए उसे कॉल कर सके। CapSkip constructor में host और port बदलें। स्थिर रिमोट एक्सेस के लिए स्टैटिक पब्लिक IP सुझाया जाता है। Server mode फिर भी आपका अपना हार्डवेयर है और फिर भी बिना किसी प्रति-हल शुल्क के है। यह पोर्ट को किसी भी पते के लिए खोल देता है, इसलिए जिन पतों को वहाँ तक नहीं पहुँचना चाहिए उनके लिए Windows Firewall का block rule जोड़ें। एक चीज़ बदलती है: हल उसी मशीन पर चलता है, इसलिए cookie उस server के IP पते से मिलती है। जब तक आप proxy नहीं देते, cookie ले जाने वाली रिक्वेस्ट को भी उसी server से निकलना होगा। proxy दें तो हल और अपनी रिक्वेस्ट, दोनों को वही दें। मोड कैसे बदलें, यह कनेक्शन सेटिंग्स में दिखाया गया है।

FAQ

संक्षेप में

Node.js में DataDome कैप्चा हल करने में चार काम होते हैं: ब्लॉक पेज पढ़ें, captchaUrl बनाएँ, dataDome() को call करें, और cookie, उसके User-Agent और IP पते के साथ रिक्वेस्ट दोहराएँ। अपनी मशीन पर हल करने का कोई शुल्क नहीं लगता, और जब कोई संरक्षित साइट बार-बार नए चैलेंज थमाती रहे, तो आप यही अपने Windows PC पर चल रहे असीमित कैप्चा सॉल्वर से पाना चाहते हैं, हालाँकि हर retry साइट से एक और ब्लॉक पेज लाती है, इसलिए गिनती कम रखें। SDK की बाकी जानकारी के लिए देखें: Node.js कैप्चा सॉल्वर पेज। इसी flow का Python संस्करण यहाँ है: Python DataDome गाइड.