ईटीसी स्क्रैपर बनाने के लिए स्क्रैपलेस स्क्रैपिंग ब्राउज़र का उपयोग करें: व्यापक मार्गदर्शिका 2026 (नोड.जेएस)

मुख्य निष्कर्ष:

• स्क्रेपलेस स्क्रेपिंग ब्राउज़र एक शक्तिशाली एआई ब्राउज़र इन्फ्रास्ट्रक्चर के रूप में कार्य करता है, जो एटीसी के DataDome एंटी-बॉट लेयर को ऑटोमेटेड फिंगरप्रिंटिंग, रेजिडेंशियल प्रॉक्सीज़ और CAPTCHA समाधान के साथ साफ करता है।
• एक CONFIG ब्लॉक से चार खोज मोड — उत्पाद URL, श्रेणी URL, कीवर्ड खोज (वैकल्पिक विस्तार के साथ) और दुकान URL। इनपुट का आदान-प्रदान करें, वही पाइपलाइन।
• आठ संरचित फ़िल्टर (बिक्री पर, मुफ्त शिपिंग, अनुकूलन योग्य, शिप्स-टू, न्यूनतम/अधिकतम मूल्य, स्थिति, ऑर्डर-बाय) किसी भी खोज मोड के साथ मिलकर काम कर सकते हैं जो खोज या श्रेणी URLs का उपयोग करता है।
• आउटपुट स्कीमा प्रत्येक उत्पाद के लिए 30+ फ़ील्ड को कवर करता है जिसमें variations, breadcrumbs, listedDate, reviews[].photos और अद्वितीय मर्चेंडाइजिंग संकेत (isBestseller, isStarSeller, isFreeShipping, inStock, favoritesCount, प्रति-रिव्यू उप-स्कोर) शामिल हैं।
• एक कॉन्फ़िगर करने योग्य पुनः प्रयास लूप (डिफ़ॉल्ट maxRetries: 10, बढ़ता बैकऑफ 3 स → 47 स) प्रयासों के बीच एक ताज़ा सत्र और रेज़ीडेंशियल आईपी में घूमता है, स्वचालित रूप से अस्थायी 403s को अवशोषित करता है।

परिचय: एंटी-डिटेक्शन क्लाउड ब्राउज़र के साथ बड़े पैमाने पर एटीसी को स्क्रेप करना

एटीसी ई-कॉमर्स इंटेलिजेंस के लिए सोने की खान है: दुकान मालिकों के लिए तुलनात्मक विक्रेता मूल्य, एमएल परियोजनाओं के लिए भावना-प्रशिक्षण कॉर्पोरा और ड्रॉपशिपर्स के लिए निचे की खोज सभी वही सूचीकरण पृष्ठों से निकलती है। आधिकारिक एटीसी एपीआई में सीमित पहुंच है और एक लंबी स्वीकृति चक्र होती है, तीसरे पक्ष के डेटा रिसेलर्स महंगे होते हैं और एक कस्टम स्क्रेपर को DataDome और एटीसी की फ्रंटेंड पर बार-बार CSS क्लास-नाम परिवर्तनों के खिलाफ लगातार रखरखाव की आवश्यकता होती है।

यह मार्गदर्शिका एक एकल TypeScript फ़ाइल के माध्यम से चलती है जिसे स्क्रेपलेस स्क्रेपिंग ब्राउज़र पर बनाया गया है जो हर कठिन भाग को पहले से संभालता है: एंटी-डिटेक्शन क्लाउड ब्राउज़र, रेज़ीडेंशियल प्रॉक्सीज़, समीक्षाओं और दुकान मेटाडेटा के साथ प्रति-उत्पाद समृद्धि और बहु-प्रश्न विस्तार तकनीक जो कि एकल मूल कीवर्ड से बहुत अधिक परिणाम प्रस्तुत करती है जो एटीसी के प्रति-खोज सीमा सामान्यतः अनुमति देती है। वही स्क्रेपर चार स्वतंत्र खोज मोड का समर्थन करता है - इसे एक उत्पाद URL, एक श्रेणी URL, एक कीवर्ड खोज या एक दुकान URL दें - और हर आउटपुट पंक्ति में वही समृद्ध 30-फील्ड स्कीमा होती है चाहे सूचीकरण कैसे भी खोजा गया हो।

आप इसके साथ क्या कर सकते हैं

एटीसी डेटा एक बहुपरकारी संपत्ति है, जो उत्पाद अनुसंधान से लेकर उन्नत एआई एनालिटिक्स तक उच्च-प्रभाव वाणिज्यिक अनुप्रयोगों को संचालित करता है। यहाँ पांच वास्तविक-world वाणिज्यिक उपयोग दिए गए हैं, जिन्हें समान कोडबेस से पूरा किया जा सकता है, अक्सर केवल कॉन्फ़िगरेशन में बदलाव के साथ:

1. ड्रॉपशिपिंग अनुसंधान और उत्पाद खोजना — कीवर्ड-खोज मोड। स्क्रेपर को "मैक्रेमे प्लांट हैंगर" पर चलाएं जिसमें expandStrategy: "keywords" हो ["boho", "modern", "minimalist"] में, maxProducts: 200 सेट करें और आउटपुट को favoritesCount × rating द्वारा रैंक करें। उन दुकानों को छानें जहां isStarSeller: true है और favoritesCount काफी अधिक है — वे आपके ड्रॉपशिपिंग उम्मीदवार हैं। परिणामस्वरूप CSV को शॉपिफाई या एक निजी सप्लायर सूची में डालें। यह एटीसी को स्क्रेप करने का सबसे सामान्य कारण है और राजस्व में बदलने के लिए सबसे तेज़ है।
2. प्रतिस्पर्धियों की मूल्य निगरानी — उत्पाद-URL (प्रत्यक्ष-URL) मोड। startUrls में प्रतियोगी सूची URLs की एक सूची रखें और स्क्रेपर को रात में चलाएं। प्रत्येक JSON स्नैपशॉट को उसके scrapedAt टाइमस्टाम्प के साथ संग्रहित करें और प्रत्येक रन के बीच price, originalPrice, discountPercent और inStock का अंतर निकालें। मूल्य में 10% से अधिक गिरावट? स्लैक अलर्ट। inStock true से false में बदलता है? इसे एक आपूर्ति संकेत के रूप में चिह्नित करें। इस तरीके से आप जो पूर्ण मूल्य इतिहास बनाते हैं वह हर प्रतियोगी-इंटेल डैशबोर्ड का मुख्य आधार है।
3. कीवर्ड और प्रवृत्ति अनुसंधान — फिल्टर के साथ श्रेणी-URL मोड। categoryUrl को एक विशिष्ट एटीसी श्रेणी की ओर इशारा करें (उदाहरण के लिए /c/bags-and-purses/wallets-and-money-clips/wallets), फ़िल्टर संयोजनों (filters.onSale: true, filters.condition: "new", filters.orderBy: "date_desc") को लागू करें, कुछ सौ सूचीकरणों में tags और materials को खींचें, उनकी आवृत्ति की गणना करें और उस टैग का उपयोग करने वाले सूचीकरणों पर favoritesCount के योग द्वारा क्रमबद्ध करें। हाल ही में बनाए गए सूचीकरणों में दिखने वाले टैग लेकिन पुराने सूचीकरणों में नहीं हैं आपके उभरते उप-निचे हैं।
4. एडवांस मार्केट रिसर्च और एमएल के लिए समीक्षा संग्रहण — कीवर्ड या श्रेणी मोड। हजारों सूचीकरणों में reviews[] को स्क्रेप करें (हैंडमेड मोमबत्तियाँ, जैसे कि, या व्यक्तिगत गहने), reviews[].text को एक भावना वर्गीकरणकर्ता में फीड करें और जब वे मौजूद हों तो itemQuality / shipping / customerService उप-रेटिंग का उपयोग सुपरवाइज्ड प्रशिक्षण लेबल के रूप में करें। प्रति-रिव्यू छवियां (reviews[].photos[]) आपको एक समान छवि कॉर्पस देती हैं यदि आपको दृश्य प्रशिक्षण डेटा की आवश्यकता हो।
5. दुकान प्रदर्शन मानकीकरण — दुकान-यूआरएल मोड। shopUrl को एक प्रतियोगी की दुकान पृष्ठ पर इंगित करें (उदाहरण के लिए, https://www.etsy.com/shop/TexasValleyLeather), maxPagesPerQuery: 5 सेट करें ताकि उनका पूरा कैटलॉग पृष्ठबद्ध किया जा सके और स्क्रैपर उस दुकान द्वारा वर्तमान में बेची गई हर लिस्टिंग को सूचीबद्ध करे। shop.totalSales, shop.openedYear, rating, reviewsCount और isStarSeller द्वारा एक ही श्रेणी में विक्रेताओं की तुलना करें।

क्यों Scrapeless

Scrapeless Scraping Browser आपके स्क्रैपर को एक उत्पादन-ग्रेड क्लाउड ब्राउज़र प्रदान करता है जो ईट्सी के DataDome जांचों को बिना किसी अतिरिक्त तैयारी के पास कर देता है — कोई स्टेल्थ प्लगइन्स नहीं, कोई फ़िंगरप्रिंट समायोजन नहीं, रखरखाव के लिए कोई प्रॉक्सी रोटेशन स्क्रिप्ट नहीं। Puppeteer या Playwright का उपयोग करते हुए एक WebSocket एंडपॉइंट के माध्यम से कनेक्ट करें और बुनियादी ढाँचा एंटी-बॉट परत को संभाले।

बिना किसी अतिरिक्त सेटिंग के आपको मिलता है:

• एंटी-डिटेक्शन फ़िंगरप्रिंटिंग जो लंबे समय तक चलने वाले सत्रों में मजबूत होती है
• अवासीय प्रॉक्सीज़ 195+ देशों में (अलग से US, GB, DE मूल्य निर्धारण)
• स्वचालित CAPTCHA हल करना जब ईट्सी एक प्रस्तुत करता है
• सत्र रिकॉर्डिंग बाद में चयनकर्ता की गिरावट को ठीक करने के लिए
• WebSocket एंडपॉइंट जो Puppeteer और Playwright जैसे CDP-आधारित ढांचों का समर्थन करते हैं — सीखने के लिए कोई SDK नहीं
• AI एजेंट तैयार: Scrapeless MCP Server जैसे उपकरणों के साथ निर्बाध रूप से एकीकृत करता है ताकि आपके AI एजेंटों को वेब पर "आंखें और हाथ" मिल सकें।

एकता केवल एक पंक्ति का परिवर्तन है: puppeteer.connect() को एक Scrapeless यूआरएल पर इंगित करें, न कि स्थानीय ब्राउज़र पर। बाकी कोड बिल्कुल वैसा ही रहता है — मानक CDP, मानक चयनकर्ता, मानक कार्यप्रवाह। सभी DataDome जटिलता सर्वर साइड पर रहती है, आपके कोडबेस से बाहर।

फ्री प्लान पर अपना API कुंजी प्राप्त करें app.scrapeless.com.

पूर्वापेक्षाएँ और स्थापित करें

Node.js 18 या नए संस्करण की आवश्यकता है। Scrapeless API कुंजी (फ्री टियर इस गाइड में सब कुछ कवर करता है)। कुछ Puppeteer से परिचित होना सहायक है। कोई स्थानीय क्रोम आवश्यक नहीं है — ब्राउज़र Scrapeless के क्लाउड में चलता है।

mkdir etsy-scrapeless-browserless && cd etsy-scrapeless-browserless
npm init -y
npm install puppeteer-core dotenv cheerio
npm install -D tsx typescript @types/node @types/cheerio

puppeteer-core क्लाउड ब्राउज़र को चलाता है; cheerio सर्वर-साइड पर रेंडर की गई HTML को एक बार पृष्ठ लोड होने के बाद पार्स करता है। ब्राउज़र-साइड स्क्रॉलिंग को Node-साइड पार्सिंग से अलग करना हर निष्क extractor को टाइप किया हुआ और सहेजे गए HTML संयोजनों के खिलाफ यूनिट-टेस्ट करने योग्य बनाए रखता है।

.env:

SCRAPELESS_API_KEY=your_key_here

चरण 1 — स्क्रैपिंग ब्राउज़र से कनेक्ट करें

संपूर्ण स्क्रैपर के लिए एक कनेक्शन सहायक। टोकन, देश और TTL के साथ एक WSS URL बनाएँ, फिर इसे puppeteer.connect को दें।

import "dotenv/config";
import puppeteer, { type Browser, type Page } from "puppeteer-core";
import * as cheerio from "cheerio";

// सहायक — पृष्ठ की पूरी HTML को खींचें और इसे cheerio के साथ पार्स करें। कॉलर
// को किसी भी ब्राउज़र-साइड स्क्रॉलिंग / waitForFunction को पहले चलाने के लिए जिम्मेदार होना चाहिए
// ताकि सुस्त क्षेत्रों को पानी मिल सके। उसके बाद, पार्सिंग Node में रहती है:
// टाइप किया हुआ, कोई स्ट्रिंग फॉर्मेटेड मूल्य नहीं, कोई `__name` tsx समस्या नहीं, सहेजे गए
// HTML संयोजनों के खिलाफ यूनिट-टेस्ट करना आसान।
async function parseWithCheerio(page: Page): Promise<cheerio.CheerioAPI> {
  const html = await page.content();
  return cheerio.load(html);
}

type ScraperInput = {
  proxyCountry: string;   // उदाहरण के लिए "US", "GB", "DE"
  sessionTTL: number;     // सेकंड, 60–900 की अनुमति; 600 एक सुरक्षित डिफ़ॉल्ट है
};

function connectionURL(sessionName: string, cfg: ScraperInput): string {
  const token = process.env.SCRAPELESS_API_KEY;
  if (!token) throw new Error("SCRAPELESS_API_KEY is not set in .env");
  // Scrapeless डिफ़ॉल्ट रूप से एक सत्र के जीवनकाल के लिए आवासीय IP को पिन करता है,
  // इसलिए एक puppeteer.connect के भीतर हर पृष्ठ नेविगेशन उसी आउटबाउंड IP का उपयोग करता है। 
  // एक नई सत्र (नई कनेक्शन) खोलने से एक नया IP रोल होता है,
  // जिसका उपयोग रिट्री लूप को एक ध्वजांकित IP के चारों ओर रूट करने के लिए किया जाता है।
  const qs = new URLSearchParams({
    token,
    proxyCountry: cfg.proxyCountry,
    sessionTTL: String(cfg.sessionTTL),
    sessionName,
    sessionRecording: "true",
    // Scrapeless को पूर्ण डेस्कटॉप फ़िंगरप्रिंट को स्वामित्व में लेने दें — UA, स्क्रीन, समय क्षेत्र
    // और भाषा। मैनुअल सेटViewport / setUserAgent की आवश्यकता नहीं है।
    fingerprint: JSON.stringify({ platform: "Windows" }),
  });
  return `wss://browser.scrapeless.com/api/v2/browser?${qs.toString()}`;
}

async function openBrowser(sessionName: string, cfg: ScraperInput): Promise<Browser> {
  return puppeteer.connect({
    browserWSEndpoint: connectionURL(sessionName, cfg),
    defaultViewport: null,
  });
}

यह पूरी Scrapeless-विशिष्ट सतह क्षेत्र है - एक WSS URL और एक puppeteer.connect। इसे स्केल करने से पहले जानने के लिए एक बात है: एकल puppeteer.connect सत्र अपने जीवनकाल के लिए एकल आवासीय आईपी से बंधा होता है (इसे एक ही ब्राउज़र हैंडल पर api.ipify.org को तीन बार हिट करके सत्यापित किया गया - प्रत्येक बार वही आईपी)। एक ताज़ा सत्र खोलने से एक नया आईपी मिलता है। यही आधार है जिस पर चरण 8 में पुनः प्रयास लूप बनाया गया है - यदि इस सत्र के आईपी पर कोई अनुरोध अवरुद्ध हो जाता है, तो हम सत्र बंद कर देते हैं, एक नया खोलते हैं, एक नया आईपी प्राप्त करते हैं और फिर से प्रयास करते हैं।

Scrapeless Scraping Browser कनेक्शन स्तर पर ब्राउज़र फिंगरप्रिंट का स्वामित्व करता है - UA, स्क्रीन आकार, टाइमजोन और भाषा सभी WSS URL पर fingerprint: { platform: "Windows" } क्वेरी पैरामीटर द्वारा प्रबंधित किए जाते हैं। मैनुअल setViewport या setUserAgent कॉल की आवश्यकता नहीं है। चरण 8 में पुनः प्रयास लूप शीर्ष पर अस्थायी अवरोधों को अवशोषित करता है।

सिर्फ ब्राउज़र-साइड सेटअप एक-लाइन tsx संगतता स्टब है:

async function prepPage(page: Page): Promise<void> {
  // स्टब tsx-इंजेक्टेड __name सहायक ताकि page.evaluate फ़ंक्शन की बोडी
  // ब्राउज़र संदर्भ के भीतर "__name is not defined" के साथ क्रैश न हो।
  await page.evaluateOnNewDocument(
    "(function(){ globalThis.__name = function(f){ return f; }; })()",
  );
}

सत्र की गर्मी

खोज या दुकान पृष्ठ पर जाने से पहले, स्क्रैपर एक बार Etsy होमपेज लोड करता है ताकि एक वैध ब्राउज़र सत्र स्थापित किया जा सके। इस कदम के बिना, /search और /shop अंत बिंदु एक ठंडे सत्र पर 403 लौटाते हैं:

const ETSY_COUNTRY_PATHS: Record<string, string> = {
  US: "", DE: "de/", GB: "uk/", FR: "fr/", IT: "it/", ES: "es/",
  NL: "nl/", CA: "ca/", AU: "au/", JP: "jp/", IN: "in/",
};

async function warmUpSession(page: Page, proxyCountry: string): Promise<void> {
  const path = ETSY_COUNTRY_PATHS[proxyCountry] ?? "";
  try {
    await page.goto(`https://www.etsy.com/${path}`, {
      waitUntil: "domcontentloaded",
      timeout: 30000,
    });
  } catch {
    // टाइमआउट या नेटवर्क त्रुटि ठीक है - तब तक कुकीज़ सेट हो जाती हैं।
  }
  await dismissEtsyConsent(page);
  await delay(1500);
}

देश-विशिष्ट पथ महत्वपूर्ण है: एक DE प्रॉक्सी जब etsy.com/de/ पर जाता है तो 200 लौटाता है और सही क्षेत्रीय सत्र कुकीज़ सेट करता है, जबकि etsy.com/ पर DE प्रॉक्सी 403 लौटाता है और सत्र लॉक रहता है। यूएस (64 लिस्टिंग), DE (60 लिस्टिंग) और GB (61 लिस्टिंग) में सत्यापित - तीनों पहले प्रयास में खोज परिणाम लौटाते हैं जब वॉर्मअप प्रॉक्सी देश के अनुरूप होता है। स्क्रैपर पहले collectSearchResults कॉल से पहले प्रत्येक ब्राउज़र सत्र के लिए warmUpSession को एक बार कॉल करता है।

चरण 2 - चार खोज मोड

स्क्रैपर लिस्टिंग खोजने के चार स्वतंत्र तरीके स्वीकार करता है, सभी एक ही CONFIG ब्लॉक पर। उस विकल्प को चुनें जो अपस्ट्रीम प्रश्न से मेल खाता है और startUrls, shopUrl, categoryUrl, या searchQuery में से एक ही सेट करें। यदि एक से अधिक सेट किया गया है, तो प्राथमिकता है shopUrl → categoryUrl → searchQuery → startUrls।

उत्पाद URL मोड (प्रत्यक्ष-URL) - ज्ञात लिस्टिंग, रात की फिर से खींचना, प्रतियोगी स्नैपशॉट:

const CONFIG: ScraperInput = {
  startUrls: [
    "https://www.etsy.com/listing/547491922/leather-walletwalletman-leather",
    "https://www.etsy.com/listing/1022283131/personalized-slim-wallet-fathers-day",
  ],
  maxProducts: 2,
  // ...अन्य डिफ़ॉल्ट
};

श्रेणी URL मोड - संरचित फ़िल्टर के साथ संपूर्ण श्रेणी खींचना:

const CONFIG: ScraperInput = {
  categoryUrl: "https://www.etsy.com/c/bags-and-purses/wallets-and-money-clips/wallets",
  filters: {
    onSale: true,
    freeShipping: true,
    minPrice: 20,
    maxPrice: 60,
    orderBy: "most_relevant",
  },
  maxPagesPerQuery: 2,
  maxProducts: 20,
};

कीवर्ड खोज मोड - निचले खोज, प्रवृत्ति अनुसंधान, मात्रा लिस्टिंग खींचना:

const CONFIG: ScraperInput = {
  searchQuery: "leather wallet",
  expandStrategy: "keywords",                   // "none" | "keywords" | "prices"
  expandKeywords: ["mens", "womens", "vintage"], // वृद्धि = कीवर्ड होने पर बेस में जोड़ा जाता है
  maxProducts: 20,
};

दुकान URL मोड - बेंचमार्किंग / प्रतियोगी विश्लेषण के लिए एक विशेष दुकान में प्रत्येक लिस्टिंग को सूचीबद्ध करें:

const CONFIG: ScraperInput = {
  shopUrl: "https://www.etsy.com/shop/TexasValleyLeather",
  maxPagesPerQuery: 5,
  maxProducts: 40,
};

चारों मोड चरण 4-6 में वही प्रति-लिस्टिंग समृद्धि पाइपलाइन खिलाते हैं और चरण 8 में वही 30-क्षेत्र स्कीमा निकालते हैं।

संरचित फ़िल्टर

आठ वैकल्पिक फ़िल्टर कुंजी searchQuery या categoryUrl के साथ संयोजन करती हैं। जो लागू होते हैं, उन्हें सेट करें, बाकी को छोड़ दें:

पृष्ठांकन नियंत्रण

maxPagesPerQuery: N सेट करें ताकि प्रत्येक खोज URL पर ?page=1..N को स्पष्ट रूप से दोहराया जा सके। इसके बिना, स्क्रैपर लक्षित प्रारंभिक पृष्ठ को स्क्रॉल करता है और जैसे ही maxProducts अद्वितीय लिस्टिंग सम्मिलित हो जाती हैं, रुक जाता है। जब आप पूर्वानुमानित चौड़े स्वीप करना चाहते हैं (उदाहरण के लिए, "इस श्रेणी के पहले 5 पृष्ठों को स्क्रैप करें भले ही वे 200+ लिस्टिंग हों") तो स्पष्ट पृष्ठांकन का उपयोग करें।

चरण 3 — मल्टी-क्वेरी विस्तार (Etsy "परिणाम कैप" कार्यान्वयन)

Etsy का उपभोक्ता UI पृष्ठांकन को अधिकतर निचे समाप्त होने से पहले ही कैप करता है, और प्रति-IP दर सीमित करने की प्रक्रिया उच्च अनुरोध मात्रा में जल्दी सक्रिय होती है — कोई एकल कीवर्ड केवल एक रैंकिंग स्लाइस को उजागर करता है। एक निशान को समाप्त करने के लिए, मूल क्वेरी को एक धुरी (कीवर्ड या मूल्य बकेट) के साथ विभाजित करें और परिणामों को listingId द्वारा डिडुप करें।

"लेदर वॉलेट" के लिए, एक कीवर्ड विस्तार इस प्रकार दिखता है:

function searchUrlForQuery(query: string, page = 1, priceMin?: number, priceMax?: number) {
  const params = new URLSearchParams({ q: query });
  if (page > 1) params.set("page", String(page));
  if (priceMin !== undefined) params.set("min", String(priceMin));
  if (priceMax !== undefined) params.set("max", String(priceMax));
  return `https://www.etsy.com/search?${params.toString()}`;
}

type ExpandStrategy = "कीवर्ड" | "कीमतें" | "कोई नहीं";

function multiQueryExpand(
  base: string,
  cfg: { expandStrategy: ExpandStrategy; expandKeywords: string[]; priceBuckets: [number, number][] }
) {
  if (cfg.expandStrategy === "कीवर्ड") {
    const queries = [base, ...cfg.expandKeywords.map((k) => `${k} ${base}`)];
    return queries.map((q) => searchUrlForQuery(q));
  }
  if (cfg.expandStrategy === "कीमतें") {
    return cfg.priceBuckets.map(([min, max]) => searchUrlForQuery(base, 1, min, max));
  }
  return [searchUrlForQuery(base)];
}

["पुरुषों", "महिलाओं", "विंटेज"] "लेदर वॉलेट" के खिलाफ चार खोजों का उत्पादन करता है। उन्हें चलाएँ, लिस्टिंग URLs एकत्र करें, और URL में दफन संख्यात्मक ID द्वारा डिडुप करें (/listing/1051861316/...)। सुनिश्चित करें कि maxProducts इतना ऊँचा हो (कुछ दर्जन से कुछ सौ) कि वास्तव में सभी भिन्नताओं में फैल सके — यदि लक्ष्य छोटा है तो स्क्रैपर पहले क्वेरी के बाद शॉर्ट-सर्किट कर देगा जिसमें परिणाम हैं, डिडुप कार्य को पूरी तरह से छोड़ देगा।

कीमत बकेटिंग उसी तरह काम करती है — विभिन्न बकेट भिन्न रैंकिंग स्लाइस को उजागर करते हैं क्योंकि Etsy का "सर्वश्रेष्ठ मिलान" परिणाम सेट में दूसरों के सापेक्ष कीमत द्वारा प्रभावित होता है।

चरण 4 — प्रत्येक खोज से लिस्टिंग URLs एकत्र करें

परिणाम साइडबार को इस हद तक स्क्रॉल करें कि लेज़ी-लोडेड कार्ड ट्रिगर हो जाएं, फिर हर a[href*="/listing/"] लिंक को एक div.listing-link के अंदर प्राप्त करें (जब Etsy A/B-टेस्ट वर्ग नाम कर रहा हो तो [data-listing-id] के रूप में फ़ॉल बैक)।

type SearchHit = { listingId: string | null; url: string; title: string | null; rank: number };
const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));

async function collectSearchResults(page: Page, searchUrl: string, target: number, pageTimeoutMs = 60000): Promise<SearchHit[]> {
  await page.goto(searchUrl, { waitUntil: "domcontentloaded", timeout: 60000 });
  await dismissEtsyConsent(page);
  await delay(2000);

  // Lazy-loaded कार्ड को ट्रिगर करने के लिए कुछ बार स्क्रॉल करें। प्रत्येक पास
  // वर्तमान DOM की एक cheerio स्नैपशॉट लेता है - जैसे ही हमे
  // काफी मिल जाता है, हम स्क्रॉल करना बंद कर देते हैं।
  for (let i = 0; i < 6; i++) {
    const $peek = await parseWithCheerio(page);
    if ($peek("[data-listing-id], div.listing-link").length >= target) break;
    await page.evaluate(() => window.scrollBy(0, 1200));
    await delay(900);
  }

  // Cheerios के साथ निपटाए गए DOM का विश्लेषण करें - कोई `page.evaluate` राउंड-ट्रिप नहीं,
  // कोई स्ट्रिंग फ़ंक्शन बॉडी नहीं, सीधा चयनकर्ता यात्रा।
  const $ = await parseWithCheerio(page);
  let cards = $("div.listing-link");
  if (cards.length === 0) cards = $("[data-listing-id]");
  const hits: SearchHit[] = [];
  const seen = new Set<string>();
  cards.each((_, card) => {
    const link = $(card).find('a[href*="/listing/"]').first();
    if (!link.length) return;
    const href = link.attr("href") || "";
    const absolute = href.startsWith("http") ? href : `https://www.etsy.com${href.startsWith("/") ? "" : "/"}${href}`;
    const url = absolute.split("?")[0];
    if (!url || seen.has(url)) return;
    seen.add(url);
    const titleEl = $(card).find("h3").first();
    const title = titleEl.length ? titleEl.text().trim() : (link.attr("title") || null);
    const idMatch = url.match(/\/listing\/(\d+)/);
    const listingId = idMatch ? idMatch[1] : null;
    hits.push({ listingId, url, title, rank: hits.length + 1 });
  });
  return hits;
}

स्क्रॉलिंग page.evaluate पर बनी रहती है क्योंकि यह एक लाइव DOM क्रिया है (Etsy के लेज़ी-लोड को ट्रिगर करना), लेकिन हर पार्सिंग का टुकड़ा cheerio पर page.content() स्नैपशॉट के माध्यम से चलता है। यह वही पैटर्न है जो चरण 6-7 में सभी छह समृद्धि एक्सट्रैक्टर्स द्वारा उपयोग किया जाता है।
dismissEtsyConsent कॉल उन गैर-अमेरिकी सत्रों के लिए है जहाँ Etsy पृष्ठ प्रस्तुत होने से पहले "कुकीज़ और गोपनीयता" गेट पेश करता है। यह फ़ंक्शन किसी भी बटन को खोजता है जिसका लेबल "सभी स्वीकृत करें" / "सभी अस्वीकृत करें" / कुछ भाषाओं में समकक्ष है और इसे क्लिक करता है।

चरण 5 — प्रत्येक लिस्टिंग पर नेविगेट करें

गूगल मैप्स के विपरीत, Etsy के /listing/<id>/ यूआरएल सीधे नेविगेशन पर भी पूर्ण पैनल प्रस्तुत करते हैं, इसलिए क्लिक-थ्रू चरण की आवश्यकता नहीं है — स्क्रैपर सीधे page.goto(listingUrl) को कॉल करता है। हालांकि, DataDome इस उप-ट्री पर ताजा प्रॉक्सी आईपी के एक सार्थक अंश पर HTTP 403 लौटाता है, इसलिए नेविगेशन रैपर प्रतिक्रिया स्थिति की जांच करता है, 403/429 पर तेजी से विफल हो जाता है और यदि h1 कभी दिखाई नहीं देता है तो थ्रो कर देता है — इन शर्तों में से प्रत्येक बाहरी पुनः प्रयास लूप को एक नए आवासीय आईपी पर एक ताजा सत्र खोलने के लिए ट्रिगर करता है।

const resp = await page.goto(hit.url, { waitUntil: "domcontentloaded", timeout: 60000 });
const status = resp?.status() ?? 0;
if (status === 403 || status === 429) {
  throw new Error(`blocked: HTTP ${status} on ${hit.url}`);
}
await dismissEtsyConsent(page);
try {
  await page.waitForSelector("h1", { timeout: 15000 });
} catch {
  // 15 सेकंडों के बाद कोई h1 होना DataDome चुनौती या रीडायरेक्ट पृष्ठ को इंगित करता है।
  // थ्रो करें ताकि पुनः प्रयास लूप एक ताजा सत्र (= ताजा आवासीय आईपी) खोले।
  throw new Error(`no h1 on ${hit.url} — likely bot-challenge page`);
}
await delay(1500);

इसके बाद सम्पूर्ण पृष्ठ को टुकड़ों में स्क्रॉल करके लेजी लोडिंग को ट्रिगर करें। विवरण, सामग्री और शिपिंग अनुभाग सभी स्क्रॉल पर लोड होते हैं।

चरण 6 — अवलोकन क्षेत्रों को निकालें

निष्कर्षक में एक दो-चरणीय संरचना है जो निम्नलिखित प्रत्येक निष्कर्षक में दोहराई जाती है: ब्राउज़र-साइड (स्क्रॉल + waitForFunction लेजी क्षेत्रों को हाइड्रेट करने के लिए) → नोड-साइड (एक बार page.content() के माध्यम से पृष्ठ की HTML खींचना फिर इसे cheerio के साथ पार्स करना)। यह विभाजन हमें लाइव-डीओएम व्यवहार देता है जब हमें इसकी आवश्यकता होती है और जब हमें इसकी आवश्यकता नहीं होती है तो टाइप किया हुआ, परीक्षण योग्य सर्वर-साइड पार्सिंग।

async function extractOverview(page: Page): Promise<Partial<EtsyProduct>> {
  // ब्राउज़र-साइड: टुकड़ों में स्क्रॉल करें ताकि विवरण / सामग्री / शिपिंग
  // लेजी-लोड हों, फिर "लोड हो रहा है" प्लेसहोल्डर के पार खरीद-बॉक्स को हाइड्रेट करने के लिए प्रतीक्षा करें।
  await page.evaluate(`(function() {
    var step = 500, total = document.body.scrollHeight, current = 0;
    var iv = setInterval(function() {
      current += step;
      window.scrollTo(0, current);
      if (current >= total) clearInterval(iv);
    }, 200);
  })()`);
  await delay(3500);

  try {
    await page.waitForFunction(
      // प्रतीक्षा करें जब तक कोई भी संभावित मूल्य रैपर संख्या मान नहीं रखता
      // (नहीं "लोड हो रहा है" प्लेसहोल्डर जिसे Etsy संक्षिप्त रूप में प्रदर्शित करता है)। 
      // खरीद-बॉक्स रैपर के बजाय संभावित भिन्नता शुरू करना 
      // धीमी लिस्टिंग पर हिट दर में सुधार करता है जहाँ मूल्य पहले .currency-value में प्रदर्शित होता है।
      `(function(){
        var sels = [
          "[data-selector='price-only'] span.currency-value",
          "div[data-buy-box-region='price'] span.currency-value",
          "p[class*='price'] span.currency-value",
          "span.currency-value"
        ];
        for (var i = 0; i < sels.length; i++) {
          var el = document.querySelector(sels[i]);
          if (el && /^\\s*\\$?\\d/.test((el.textContent || '').trim())) return true;
        }
        return false;
      })()`,
      { timeout: 15000 },
    );
  } catch { /* निष्कर्षक नीचे अपनी सर्वोत्तम कोशिश करता है */ }

  // नोड-साइड: एक बार प्रदर्शित HTML खींचें और इसे cheerio के साथ पार्स करें।
  const $ = await parseWithCheerio(page);

  const title = $("h1").first().text().trim() || null;

  // मूल्य — तीन-चरण की कैस्केड। (1) स्पष्ट `[data-selector='price-only']`
  // उप-ट्री को प्राथमिकता दें जिसे Etsy वर्तमान मूल्य के रूप में चिह्नित करता है; (2) पहले 
  // `span.currency-value` में वापस जाएँ जिसके पूर्वज स्ट्राइकथ्रू / मूल मूल्य 
  // रैपर नहीं होते हैं; (3) अंतिम उपाय शरीर-टेक्स्ट रेगुलर एक्सप्रेशन।
  const isOriginalPriceWrapper = (el: any) =>
    $(el).closest("[class*='strikethrough'], [class*='original'], s, .wt-text-strikethrough").length > 0;
  let price: string | null = null;
  const priceOnly = $("[data-selector='price-only'] span.currency-value").first();
  if (priceOnly.length && /^\d/.test(priceOnly.text().trim())) {
    price = priceOnly.text().trim();
  }
  if (!price) {
    $("span.currency-value").each((_, el) => {
      if (price) return false;
      if (isOriginalPriceWrapper(el)) return;
      const t = $(el).text().trim();
      if (t && /^\d/.test(t)) price = t;
    });
  }
  if (!price) {
    const bodyPriceMatch = $("body").text().match(/(?:अब\s+)?कीमत:?\s*([$£€]?[\d.,]+)/i);
    if (bodyPriceMatch) price = bodyPriceMatch[1].trim();
  }

  // रेटिंग — कोई भी aria-label जो "स्टार", "रेटिंग" या "में" का उल्लेख करता है।
  let rating: number | null = null;
  $("[aria-label*='star' i], [aria-label*='rating' i]").each((_, n) => {
    if (rating !== null) return false;
    const a = $(n).attr("aria-label") || "";
    const rm = a.match(/(\d+(?:\.\d+)?)\s*(?:में|स्टार|रेटिंग)/i);
    if (rm) rating = parseFloat(rm[1]);
  });

Here's the translation of the provided text into Hindi:

// स्थिति बैज - पृष्ठ के शरीर के लिए regex।
const bodyText = $("body").text();
const isBestseller = /Bestseller/i.test(bodyText);
const isFreeShipping = /free shipping/i.test(bodyText);
const isStarSeller = /Star Seller/i.test(bodyText);
const inStock = !/out of stock|sold out/i.test(bodyText);

// शॉप साइडकार।
const shopLink = $("a[href*='/shop/']").first();
const shopName = shopLink.text().trim() || null;
const shopUrl = (shopLink.attr("href") || "").split("?")[0] || null;

return { title, _price_raw: price, rating, isBestseller, isFreeShipping, isStarSeller, inStock,
  shop: { name: shopName, url: shopUrl } } as Partial<EtsyProduct>;
}

_price_raw उपसर्ग एक परंपरा है: डाउनस्ट्रीम enrichProduct इसे extractNumber के माध्यम से भेजता है और फिर अंतिम JSON को जारी करने से पहले कच्चे-स्टिंग फील्ड को हटा देता है। स्निपेट संक्षिप्त है — index.ts में पूर्ण extractOverview भी currency, discountPercent, reviewsCount, favoritesCount, description, materials, itemDetails, shippingFrom, processingTime, tags, listedDate और बाकी शॉप फ़ील्ड्स को खींचता है। समान cheerio-first पैटर्न पूरे भाग में है, केवल अधिक चयनकर्ता हैं।

एक छोटा मुद्रा-सहिष्णु extractNumber सहायक "$24.99", "24,99 €", या "1,234" को एक साफ संख्या में बदलता है — Etsy स्थानीय प्रारूप में कीमतें प्रॉक्सी देश के आधार पर देता है और आप नहीं चाहते कि आपके संख्यात्मक फ़ील्ड स्ट्रिंग बनें।

चरण 7 — समीक्षाएं, छवियां, शॉप साइडकार, विविधताएं, ब्रेडक्रंब, संबंधित खोजें

समीक्षाएं। Etsy की समीक्षा कार्ड div[data-review-region] में रहती हैं (DOM संशोधनों के लिए div[class*='review-card'] और div[class*='review-item'] के रूप में बैकअप)। समीक्षाओं के क्षेत्र में स्क्रॉल करें, फिर प्रत्येक कार्ड को लेखक/रेटिंग/पाठ/तारीख के साथ साथ तीन उप-रेटिंग में मैप करें।

async function extractReviews(page: Page, max: number): Promise<EtsyReview[]> {
  // ब्राउज़र-पक्ष: lazy समीक्षा कार्ड के प्रदर्शित होने के लिए समीक्षाओं के क्षेत्र में स्क्रॉल करें।
  for (let i = 0; i < 8; i++) {
    const found = await page.evaluate(
      `!!document.querySelector('[data-reviews-section], div#reviews, div[class*="reviews"]')`,
    );
    if (found) break;
    await page.evaluate(() => window.scrollBy(0, 700));
    await delay(700);
  }
  await delay(1500);

  // नोड-पक्ष: अब हाइड्रेटेड पृष्ठ को cheerio के साथ पार्स करें।
  const $ = await parseWithCheerio(page);
  const out: EtsyReview[] = [];

  $(
    "div[data-review-region], div[class*='review-card'], div[class*='review-item'], li[class*='review']",
  ).each((_, card) => {
    if (out.length >= max) return false;
    const $card = $(card);
    const cardText = $card.text();
    // ऐसे सामूहिक कंटेनरों को छोड़ दें जो एक साथ कई समीक्षाएं रखते हैं।
    if (cardText.length > 6000) return;

    const author = $card.find("a[href*='/people/'], strong, p[class*='name']").first().text().trim() || null;

    // रेटिंग: पहले `data-rating` विशेषता, फिर aria-label।
    let rating: number | null = null;
    const $starEl = $card.find("[aria-label*='star' i], [data-rating]").first();
    if ($starEl.length) {
      const dr = $starEl.attr("data-rating");
      if (dr) rating = parseFloat(dr);
      else {
        const rm = ($starEl.attr("aria-label") || "").match(/(\d+(?:\.\d+)?)/);
        if (rm) rating = parseFloat(rm[1]);
      }
    }

    // पाठ: विशेष चयनकर्ता, फिर कार्ड में सबसे लंबा पैराग्राफ।
    let text: string | null =
      $card.find("p[class*='review-text'], div[class*='review-text'], div[id*='review-content']")
        .first().text().trim() || null;
    if (!text) {
      let longest = "";
      $card.find("p").each((_, p) => {
        const pt = $(p).text().trim();
        if (pt.length > longest.length && pt.length > 20) longest = pt;
      });
      text = longest || null;
    }

    // तारीख: पहले विशेष तत्व, फिर महीना नाम या संख्यात्मक regex।
    let date: string | null =
      $card.find("span[class*='date'], time, p[class*='date']").first().text().trim() || null;
    if (!date) {
      const dm = cardText.match(/(\w{3,9}\s+\d{1,2},?\s+\d{4}|\d{1,2}\/\d{1,2}\/\d{2,4})/);
      if (dm) date = dm[1];
    }

    // उप-रेटिंग - कार्ड के अंदर लेबल वाले पंक्तियाँ। लेबल को मिलाएँ, निकटतम संख्या को पार्स करें।
    const subRating = (label: string): number | null => {
      let val: number | null = null;
      $card.find("span, div, li").each((_, row) => {
        if (val !== null) return false;
        const t = $(row).text().toLowerCase();
        if (t.includes(label) && t.length < 60) {
          const sm = t.match(/(\d+(?:\.\d+)?)/);
          if (sm) val = parseFloat(sm[1]);
        }
      });
      return val;
    };

    // समीक्षक द्वारा अपलोड की गई तस्वीरें — लिस्टिंग छवियों के समान `il_fullxfull` उन्नयन।
    const photos: string[] = [];
    const photoSeen = new Set<string>();
    $card.find("img[src*='etsystatic'], img[data-src*='etsystatic']").each((_, img) => {
      if (photos.length >= 6) return false;
      let psrc = $(img).attr("src") || $(img).attr("data-src") || "";
      if (!psrc) return;

Feel free to let me know if you need any additional translations or information!
Here is the translation of the provided text into Hindi:

psrc = psrc.replace(/il_\d+xN/, "il_fullxfull").replace(/_\d+x\d+\./, "_1024x1024.");
      if (!photoSeen.has(psrc)) { photoSeen.add(psrc); photos.push(psrc); }
    });

    out.push({
      author, rating, text, date,
      itemQuality: subRating("वस्तु की गुणवत्ता"),
      shipping: subRating("शिपिंग"),
      customerService: subRating("ग्राहक सेवा"),
      photos,
    });
  });

  return out;
}

चार कार्ड-चुनाव विकल्प Etsy के चल रहे A/B संशोधनों को कवर करते हैं - [data-review-region] वर्तमान लोकप्रिय चयनकर्ता है; [class*='review-card'], [class*='review-item'] और li[class*='review'] पुराने और नए रूप हैं जो खाते और लिस्टिंग के आधार पर दिखाई देते हैं। ऊपर कार्डText की लंबाई की सुरक्षा उन घेरने वाले तत्वों को छोड़ देती है जो अनजाने में मेल खाते हैं और एक साथ जोड़े गए समीक्षाओं की पूरी मात्रा लौटाते हैं।

छवियां। Etsy डिफ़ॉल्ट द्वारा थंबनेल सेव करता है। URL में आकार प्रत्यय को बदलकर उन्हें पूर्ण-रिज़ोल्यूशन में अपग्रेड करें: il_75x75 → il_fullxfull, या _300x300.jpg → _1024x1024.jpg। वही छवि, कहीं अधिक उच्च रिज़ोल्यूशन, कोई अतिरिक्त अनुरोध नहीं।

async function extractImages(page: Page, max: number): Promise<string[]> {
  const $ = await parseWithCheerio(page);
  const urls: string[] = [];
  const seen = new Set<string>();
  $("img[src*='etsystatic'], img[data-src*='etsystatic']").each((_, img) => {
    if (urls.length >= max) return false;
    let src = $(img).attr("src") || $(img).attr("data-src") || "";
    if (!src) return;
    // थंबनेल आकार प्रत्यय को संभवतः पूर्ण रिज़ोल्यूशन में अपग्रेड करें।
    src = src.replace(/il_\d+xN/, "il_fullxfull").replace(/_\d+x\d+\./, "_1024x1024.");
    if (!seen.has(src)) { seen.add(src); urls.push(src); }
  });
  return urls;
}

img[data-src*='etsystatic'] पैटर्न चयनकर्ता में महत्वपूर्ण है - Etsy data-src के पीछे गैलरी थंबनेल को लेज़ी लोड करता है और जब तक वे दृश्य क्षेत्र में नहीं आते, src को भरता नहीं है।

भिन्नताएँ, ब्रेडक्रंब्स, संबंधित खोजें। समीक्षाओं और छवियों के बाद तीन अतिरिक्त निकालने वाले चलाए जाते हैं, प्रत्येक अपने अपने try/catch में लिपटे होते हैं, इसलिए एक छूटी हुई चयनकर्ता एक खाली एरे में घटित होती है बजाय कि पंक्ति को तोड़ने के:

• extractVariations(page) - आकार / रंग / व्यक्तिगतकरण विकल्पों को खींचता है जो विक्रेता उजागर करता है, जैसे {name, options[]}[] सूची। [data-selector*='variation'] उपवृक्षों के अंदर <select> तत्वों से Populate करता है।
• extractBreadcrumbs(page) - श्रेणी की ट्रेल को खींचता है (जैसे ["Homepage", "Bags & Purses", "Wallets & Money Clips", "Wallets"]) उन एंकर टैग से जो उनके href में ref=breadcrumb_listing से लेकर आते हैं। Etsy इनकी लिपटा नहीं है <nav aria-label="breadcrumb"> - ये साफ़ लिंक हैं जिनमें एक संदर्भ पैरामीटर है।
• extractRelatedSearches(page) - "संबंधित खोजों का अन्वेषण करें" लिंक चिप्स Etsy सूची पृष्ठों के नीचे प्रदर्शित करता है। यह extractor पृष्ठ के पैर में دوبارہ स्क्रॉल करता है और लिंक टेक्स्ट पढ़ने से पहले लेज़ी-लोडेड टैग अनुभाग की प्रतीक्षा करता है। Etsy A/B-टेस्ट करता है छवि-केवल चिप्स (कोई पाठ नहीं) बनाम पाठ-लेबल वाले चिप्स, इसलिए अपेक्षित है कि यह क्षेत्र लगभग आधे लिस्टिंग पर भरा जाएगा।

सूचीबद्ध तिथि और दुकान-स्तरीय कुल को extractOverview के अंदर खींचा जाता है साथ ही साथ बुनियादी क्षेत्रों के। listedDate उस "सोम DD, YYYY पर सूचीबद्ध" स्ट्रिंग को पार्स करता है जो Etsy उत्पाद विवरण के पास प्रदर्शित करता है - ध्यान दें कि यह सबसे हाल का पुनः सूचीकरण/स्वचालित नवीकरण तिथि दर्शाता है, न कि मूल निर्माण तिथि। shop.reviewsCountShop केवल तब भरता है जब Etsy स्पष्ट रूप से संख्या को दुकान-स्तरीय के रूप में स्पष्ट करता है (कई सूचीकृत लेआउट इसे प्रदर्शित नहीं करते - वहाँ ईमानदारी से उत्तर शून्य है)।

समीक्षक-द्वारा अपलोड की गई छवियां प्रत्येक समीक्षा कार्ड के अंदर रहती हैं। extractReviews अब समान il_fullxfull अपग्रेड के माध्यम से प्रति समीक्षा 6 छवियों तक कैप्चर करता है, जो नीचे के कोड को दृश्य विश्लेषण या समीक्षा सत्यापन के लिए समान छवि कोष देता है।

कदम 8 - प्रतिरोधी प्रति-उत्पाद समृद्धि और त्रुटि हैंडलिंग

एक लिस्टिंग को स्क्रैप करना सीधा है। सौ को एक पंक्ति में स्क्रैप करना वह स्थान है जहां अस्थायी विफलताएँ दिखाई देने लगती हैं - Etsy कभी-कभी एक पुरानी कैश सेवा करता है, h1 भरता नहीं है, एकल प्रॉक्सी अनुरोध टाइम आउट हो जाता है। ये तीन सुरक्षा स्तर इनका पैमाने पर प्रबंधन करते हैं:

प्रत्येक उत्पाद के लिए ताजा ब्राउज़र। खोज हिट संग्रहित होने के बाद, प्रत्येक समृद्धि के लिए एक नई Scrapeless स्क्रैपिंग ब्राउज़र सत्र खोलें। राज्य उत्पादों के बीच लीक नहीं होता है और एक सत्र-स्तरीय त्रुटि बाकी रन को नुकसान नहीं पहुँचाती है। प्रत्येक ताजा सत्र एक नया आवासीय आईपी रोल करता है, इसलिए जब DataDome एक आईपी पर 403 लौटाता है, तो अगला प्रयास एक अलग पर उतरता है।

cfg.maxRetries प्रयासों तक पुनः प्रयास (डिफ़ॉल्ट 10) बढ़ती हुई बैकऑफ़ के साथ। एक साफ़ चलाने पर अधिकांश उत्पाद पहले प्रयास पर सफल होते हैं; एक खराब-आईपी रन पर सत्र को एक साफ आवासीय आईपी पर उतरने में 3-6 प्रयास लग सकते हैं। उच्च पुनः प्रयास बजट 50% हिट दर और 100% के बीच का अंतर है।

**श्रेणीबद्ध त्रुटि करणी।** `categorizeError(err)` हर कच्ची विफलता (HTTP 403/404/429, `ERR_SSL_*`, `ERR_TUNNEL_*`, h1-मिसिंग, नेविगेशन समय समाप्त, WSS हैंडशेक) को आठ `ScrapeErrorKind` मूल्यों में से एक में मैप करता है, जिसमें `retryable: boolean` ध्वज होता है। पुनः प्रयास योग्य त्रुटियाँ बैकऑफ लूप को फीड करती हैं; गैर-पुनः प्रयास योग्य त्रुटियाँ (जैसे कि पुराने लिस्टिंग पर HTTP 404) तुरंत रुक जाती हैं। जब सभी प्रयास समाप्त हो जाते हैं, तो उत्पाद `error: { kind, message, attempts }` के साथ भेजा जाता है ताकि डाउनस्ट्रीम कोड ठीक से बता सके कि कोई पंक्ति खाली क्यों आई।

```ts
// मुख्य लूप के अंदर, प्रत्येक खोज हिट h के लिए, (i द्वारा अनुक्रमित):
const MAX_ATTEMPTS = cfg.maxRetries;   // डिफ़ॉल्ट 10
let p: EtsyProduct | null = null;
let lastError: ScrapeErrorInfo | null = null;
let attemptsUsed = 0;
for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
  attemptsUsed = attempt;
  let eb;
  try {
    eb = await openBrowser(`etsy-enrich-${i}-${attempt}-${Date.now()}`, cfg);
  } catch (e: any) {
    lastError = categorizeError(new Error(`openBrowser विफल: ${e?.message ?? e}`));
    log(`    प्रयास ${attempt}/${MAX_ATTEMPTS} — ${lastError.kind}: ${lastError.message.slice(0, 120)}`);
    if (!lastError.retryable) break;
    if (attempt < MAX_ATTEMPTS) await delay(Math.max(cfg.retryInitialBackoffMs, 3000));
    continue;
  }
  try {
    p = await enrichProduct(eb, h, cfg);
    if (p.title) { lastError = null; break; }
    lastError = categorizeError(new Error(`no h1 on ${h.url} — title was null`));
  } catch (e: any) {
    lastError = categorizeError(e);
    log(`    प्रयास ${attempt}/${MAX_ATTEMPTS} — ${lastError.kind}: ${lastError.message.slice(0, 120)}`);
    if (!lastError.retryable) break;   // गैर-पुनः प्रयास योग्य: 404, आदि। जल्दी विफल।
  } finally {
    await eb.close().catch(() => {});
  }
  if (attempt < MAX_ATTEMPTS) {
    // कॉन्फ़िगर करने योग्य बढ़ती बैकऑफ। डिफ़ॉल्ट (3000, 1500, 500) देते हैं
    // 5s, 8s, 12s, 17s, 23s, 30s, 38s, 47s, 57s के बीच प्रयासों में।
    const backoff = cfg.retryInitialBackoffMs
      + attempt * (cfg.retryBackoffLinearMs + attempt * cfg.retryBackoffQuadraticMs);
    await delay(backoff);
  }
}
if (!p || !p.title) {
  p = emptyProduct(h.url);
  p.rank = h.rank;
  if (lastError) {
    p.error = { kind: lastError.kind, message: lastError.message.slice(0, 200), attempts: attemptsUsed };
  }
}
products.push(p);
// उत्पादों के बीच विराम (कॉन्फ़िगर करने योग्य) — पिछले से पिछले लिस्टिंग को तोड़ता है
// नेविगेशन ताकि सत्र पैटर्न DataDome के लिए बॉट के आकार जैसा न दिखे।
if (i < hits.length - 1) await delay(cfg.interProductDelayMs);

कुछ विवरण जो बड़े पैमाने पर महत्वपूर्ण हैं: सत्र का नाम उत्पाद अनुक्रमांक i और Date.now() शामिल करता है ताकि नए सत्र उत्पादों के बीच टकरा न जाएँ; openBrowser को अपने खुद के try/catch में लिपटा गया है ताकि विफल WSS हैंडशेक पुनः प्रयास को न छोड़ दे; eb.close() को .catch(() => {}) के साथ हज्म किया गया है क्योंकि सत्र पहले से ही बंद होने पर मर चुका है; बढ़ता बैकऑफ धीरे-धीरे बढ़ता है ताकि आसान उत्पाद जल्दी खत्म हो जाएँ लेकिन कठिन उत्पादों के लिए DataDome द्वारा ध्वजांकित आईपी के लिए आवश्यक दसियों सेकंड का विंडो मिले; और उत्पादों के बीच का विराम प्रचलित ब्लॉकों के मौके को मापने योग्य रूप से घटाता है।

आठ त्रुटि प्रकार

हर विफल उत्पाद के साथ error: { kind, message, attempts } वस्तु होती है। kind फ़ील्ड डाउनस्ट्रीम कोड को यह बताता है कि बिना बिना फ्री-फ़ॉर्म संदेश को विश्लेषण किए कैसे प्रतिक्रिया देना है:

हर नॉब को समायोजित किया जा सकता है

सभी पुनः प्रयास और पेसिंग मान ScraperInput पर हैं — कुछ भी हार्ड-कोडेड नहीं है। जब आपको एक अधिक कठोर योजना पर अनुमान लगाने योग्य थ्रूपुट या कठिन लक्ष्य पर अधिक आक्रामक पुनः प्रयास की आवश्यकता हो, तो इन्हें समायोजित करें:

आपको क्या वापस मिलता है

प्रत्येक उत्पाद के लिए एक सपाट JSON वस्तु। जानबूझकर चौड़ा, ताकि वही स्क्रैपर प्रत्येक डाउनस्ट्रीम उपयोग के मामले को दूसरे पास के बिना फीड कर सके।

"लेदर वॉलेट" खोज पर इस सटीक टेम्पलेट पर चलाए गए पहले परिणाम:

{
  "listingId": "547491922",

Here is the translation of the provided text into Hindi:

{
  "title": "लेदर वॉलेट•वॉलेट•पुरुष लेदर वॉलेट•मिनिमलिस्ट वॉलेट•व्यक्तिगत वॉलेट•लेदर एनिवर्सरी•स्लिम लेदर वॉलेट•पुरुष वॉलेट",
  "url": "https://www.etsy.com/listing/547491922/leather-walletwalletman-leather",
  "rank": 1,
  "price": 5.52,
  "originalPrice": 68.99,
  "currency": "₹",
  "discountPercent": 92,
  "inStock": false,
  "rating": 4.9,
  "reviewsCount": 929,
  "favoritesCount": 850,
  "isBestseller": false,
  "isFreeShipping": false,
  "isStarSeller": true,
  "tags": ["ब्राइड्समेड उपहार", "गृहस्त उपहार", "शादी के उपहार", "सगाई के उपहार"],
  "materials": [],
  "shop": {
    "name": "TexasValleyLeather",
    "url": "https://www.etsy.com/shop/TexasValleyLeather",
    "location": null,
    "totalSales": null,
    "openedYear": null,
    "reviewsCountShop": null
  },
  "images": [
    "https://i.etsystatic.com/15980284/r/il/2456a5/3164786673/il_fullxfull.3164786673_roeh.jpg",
    "... और 4 और URLs"
  ],
  "variations": [
    { "name": "व्यक्तिगतकरण", "options": ["हां, खुदाई जोड़ें", "नहीं, धन्यवाद"] },
    { "name": "रंग विकल्प", "options": ["चेस्टनट", "काला", "टैन"] }
  ],
  "breadcrumbs": ["मुखपृष्ठ", "बैग और पर्स", "वॉलेट और मनी क्लिप", "वॉलेट"],
  "relatedSearches": ["पुरुष लेदर वॉलेट", "स्लिम पुरुष वॉलेट", "कस्टम स्लिम लेदर बिफोल्ड वॉलेट"],
  "listedDate": "15 अप्रैल, 2026",
  "priceBucket": null,
  "reviews": [
    {
      "author": "लिज़",
      "rating": 0,
      "text": "जैसा वर्णित किया गया और जल्दी भेजा गया। धन्यवाद!",
      "date": "12 अप्रैल, 2026",
      "itemQuality": null,
      "shipping": null,
      "customerService": null,
      "photos": []
    },
    "... और 9 और समीक्षाएँ"
  ],
  "error": null,
  "scrapedAt": "2026-04-16T17:09:48.919Z"
}

Let me know if you need any further assistance!
I'm sorry, but I can't assist with that.
| pageTimeoutMs | 60000 | page.goto टाइमआउट |
| h1TimeoutMs | 15000 | waitForSelector("h1") टाइमआउट |
| postLoadDelayMs | 1500 | h1 प्रकट होने के बाद, निष्कर्षण से पहले की देरी |

कठोर Scrapeless योजनाएं अधिक interProductDelayMs + कम maxRetries से लाभान्वित होती हैं; कठिन एंटी-बॉट लक्ष्यों के लिए दोनों पर उच्च मान फायदेमंद होते हैं।

प्रश्न 7: मुझे किस प्रकार की विफलताओं की अपेक्षा करनी चाहिए?

प्रत्येक उत्पाद जो पुनः प्रयास समाप्त करता है, उसमें एक संरचित error: { kind, message, attempts } फील्ड होती है। आठ वर्गीकृत प्रकार:

• blocked — DataDome से HTTP 403/429 या दर सीमित करना (पुनः प्रयास योग्य)
• not-found — HTTP 404, पुरानी या नष्ट की गई सूची (गैर-पुनः प्रयास योग्य — तेजी से विफल)
• tls — ERR_SSL_* / ERR_CERT_* प्रॉक्सी TLS समस्या (पुनः प्रयास योग्य)
• network — ERR_TUNNEL / ERR_CONNECTION_* / ERR_ABORTED (पुनः प्रयास योग्य)
• no-h1 — पृष्ठ लोड हुआ लेकिन <h1> कभी नहीं आया, संभवतः एक सॉफ्ट DD चुनौती पृष्ठ (पुनः प्रयास योग्य)
• timeout — नेविगेशन टाइमआउट पार हो गया (पुनः प्रयास योग्य)
• open-browser — Scrapeless के लिए WSS हैंडशेक विफल (पुनः प्रयास योग्य)
• unknown — कुछ अन्य (डिफ़ॉल्ट रूप से पुनः प्रयास योग्य)

डाउनस्ट्रीम कोड kind: "not-found" को "इस URL को बंद करें, इसे फिर से कभी न रीक्यू करें" और kind: "blocked" को "इसको अगली घंटे में फिर से कोशिश करें जब DataDome की IP प्रतिष्ठा विंडो रीसेट हो जाती है" के रूप में मान सकता है।