हेडलेस ब्राउज़र डिटेक्शन को कैसे बायपास करें: पार्सिंग के लिए गाइड

```html

आधुनिक वेबसाइटें स्वचालित ब्राउज़रों (Selenium, Puppeteer, Playwright) को पहचानना सीख गई हैं और उनके अनुरोधों को ब्लॉक कर देती हैं। Headless-ब्राउज़र कई डिजिटल निशान छोड़ते हैं, जिनके आधार पर एंटी-बॉट सिस्टम स्वचालन को मिलीसेकंड में पहचान लेते हैं। इस मार्गदर्शिका में, हम सभी headless-ब्राउज़रों को छिपाने के तरीकों का विश्लेषण करेंगे, Python और JavaScript में कोड के उदाहरणों के साथ, ताकि आपके पार्सर बिना किसी ब्लॉक के स्थिरता से काम कर सकें।

यह लेख उन डेवलपर्स के लिए है जो वेब स्क्रैपिंग, परीक्षण स्वचालन या सुरक्षित वेबसाइटों से डेटा संग्रहण में लगे हुए हैं। हम डिटेक्शन के तकनीकी विवरण और सुरक्षा को बायपास करने के लिए व्यावहारिक समाधान पर चर्चा करेंगे।

वेबसाइटें headless-ब्राउज़रों का पता कैसे लगाती हैं: प्रमुख तरीके

एंटी-बॉट सिस्टम ब्राउज़र की बहु-स्तरीय जांच का उपयोग करते हैं, सैकड़ों पैरामीटर का विश्लेषण करते हैं। Headless-ब्राउज़र सामान्य ब्राउज़रों से कई संकेतों में भिन्न होते हैं, जिन्हें केवल User-Agent को बदलकर छिपाना संभव नहीं है। डिटेक्शन के तरीकों को समझना प्रभावी छिपाने की दिशा में पहला कदम है।

स्वचालन के लिए JavaScript मार्कर

सबसे सामान्य तरीका JavaScript गुणों की जांच करना है, जो केवल स्वचालित ब्राउज़रों में दिखाई देते हैं:

navigator.webdriver — Selenium और Puppeteer में true लौटाता है
window.chrome — headless Chrome में अनुपस्थित है
navigator.plugins.length — headless मोड में 0 है
navigator.languages — अक्सर खाली एरे या केवल "en-US" होता है
navigator.permissions — API headless मोड में अलग तरह से काम करता है

Chrome DevTools प्रोटोकॉल का विश्लेषण

Puppeteer और Playwright Chrome DevTools प्रोटोकॉल (CDP) के माध्यम से ब्राउज़र को नियंत्रित करते हैं। CDP कनेक्शन की उपस्थिति को विशेष JavaScript जांचों के माध्यम से खोजा जा सकता है, जो window.cdc_ ऑब्जेक्ट का विश्लेषण करते हैं या माउस और कीबोर्ड इवेंट्स के व्यवहार में विसंगतियों की जांच करते हैं।

Canvas और WebGL फ़िंगरप्रिंटिंग

Headless-ब्राउज़र समान Canvas और WebGL फ़िंगरप्रिंट उत्पन्न करते हैं, क्योंकि वे हार्डवेयर के बजाय सॉफ़्टवेयर रेंडरिंग का उपयोग करते हैं। एंटी-बॉट सिस्टम एक अदृश्य Canvas तत्व बनाते हैं, उस पर टेक्स्ट या आकृतियाँ बनाते हैं और छवि का हैश निकालते हैं। यदि हजारों उपयोगकर्ताओं का हैश समान है — तो यह बॉट्स का संकेत है।

व्यवहारात्मक विश्लेषण

आधुनिक सिस्टम (DataDome, PerimeterX, Cloudflare Bot Management) माउस की गति, स्क्रॉलिंग की गति, क्लिक पैटर्न का विश्लेषण करते हैं। Headless-ब्राउज़र क्रियाएँ तुरंत और बिना स्वाभाविक देरी के करते हैं, जो स्वचालन को उजागर करता है। इसके अलावा, घटनाओं का विश्लेषण किया जाता है: सामान्य ब्राउज़र में क्लिक करने से पहले हमेशा mousemove इवेंट होता है, जबकि बॉट्स अक्सर बिना माउस की पूर्व गति के क्लिक करते हैं।

महत्वपूर्ण: आधुनिक एंटी-बॉट सिस्टम मशीन लर्निंग का उपयोग करते हैं ताकि एक साथ सैकड़ों पैरामीटर का विश्लेषण किया जा सके। केवल एक पैरामीटर (जैसे, User-Agent) को छिपाना ब्लॉकिंग से सुरक्षा नहीं करेगा — एक समग्र दृष्टिकोण की आवश्यकता है।

navigator.webdriver और अन्य JavaScript मार्करों को हटाना

navigator.webdriver प्रॉपर्टी Selenium और अन्य WebDriver उपकरणों का पता लगाने का सबसे सरल तरीका है। सामान्य ब्राउज़र में यह प्रॉपर्टी undefined लौटाती है, जबकि स्वचालित में true लौटाती है। इसे पृष्ठ लोड होने से पहले JavaScript कोड चलाकर हटाया जा सकता है।

Selenium (Python): CDP के माध्यम से webdriver को हटाना

Selenium के लिए, किसी भी पृष्ठ को लोड करने से पहले JavaScript चलाने के लिए Chrome DevTools प्रोटोकॉल का उपयोग करना आवश्यक है:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('--disable-blink-features=AutomationControlled')

driver = webdriver.Chrome(options=options)

# CDP के माध्यम से navigator.webdriver को हटाना
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
    '''
})

driver.get('https://example.com')

--disable-blink-features=AutomationControlled विकल्प उस फ्लैग को बंद करता है जिसे Chrome स्वचालन मोड में जोड़ता है। यह एक बुनियादी सुरक्षा है, जिसे अन्य तरीकों के साथ संयोजित करना आवश्यक है।

Puppeteer (Node.js): Page.evaluateOnNewDocument के माध्यम से छिपाना

Puppeteer में पृष्ठ लोड होने से पहले कोड चलाने के लिए page.evaluateOnNewDocument() विधि का उपयोग किया जाता है:

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: true,
        args: ['--disable-blink-features=AutomationControlled']
    });
    
    const page = await browser.newPage();
    
    // webdriver और अन्य मार्करों को हटाना
    await page.evaluateOnNewDocument(() => {
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
        
        // chrome ऑब्जेक्ट जोड़ना
        window.chrome = {
            runtime: {}
        };
        
        // प्लगइन्स का अनुकरण
        Object.defineProperty(navigator, 'plugins', {
            get: () => [1, 2, 3, 4, 5]
        });
    });
    
    await page.goto('https://example.com');
})();

Playwright: अंतर्निहित छिपाने के विकल्प

Playwright बॉक्स से बाहर अधिक उन्नत छिपाने की सुविधा प्रदान करता है, लेकिन अतिरिक्त सेटिंग्स की आवश्यकता होती है:

const { chromium } = require('playwright');

(async () => {
    const browser = await chromium.launch({
        headless: true,
        args: ['--disable-blink-features=AutomationControlled']
    });
    
    const context = await browser.newContext({
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    });
    
    const page = await context.newPage();
    
    await page.addInitScript(() => {
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
    });
    
    await page.goto('https://example.com');
})();

Chrome DevTools प्रोटोकॉल को छिपाना

Puppeteer और Playwright CDP कनेक्शन के निशान छोड़ते हैं, जिन्हें window ऑब्जेक्ट का विश्लेषण करके खोजा जा सकता है। एंटी-बॉट सिस्टम cdc_, $cdc_ या __webdriver_ के साथ प्रीफिक्स वाले वेरिएबल्स की खोज करते हैं, जो Chrome DevTools प्रोटोकॉल के माध्यम से कनेक्ट होने पर बनाए जाते हैं।

CDP वेरिएबल्स को हटाना

निम्नलिखित स्क्रिप्ट स्वचालन से संबंधित सभी वेरिएबल्स को window ऑब्जेक्ट से हटा देती है:

await page.evaluateOnNewDocument(() => {
    // cdc_ प्रीफिक्स वाले सभी वेरिएबल्स को हटाना
    const cdcProps = Object.keys(window).filter(prop => 
        prop.includes('cdc_') || 
        prop.includes('$cdc_') || 
        prop.includes('__webdriver_')
    );
    
    cdcProps.forEach(prop => {
        delete window[prop];
    });
    
    // CDP को छिपाने के लिए document.__proto__ को फिर से परिभाषित करना
    const originalQuery = document.querySelector;
    document.querySelector = function(selector) {
        if (selector.includes('cdc_')) return null;
        return originalQuery.call(this, selector);
    };
});

पैच किए गए Chromium संस्करणों का उपयोग करना

ऐसे संशोधित Chromium बिल्ड हैं जो CDP के निशान नहीं छोड़ते। उदाहरण के लिए, puppeteer-extra पुस्तकालय puppeteer-extra-plugin-stealth प्लगइन के साथ स्वचालन को छिपाने के लिए दर्जनों पैच स्वचालित रूप से लागू करता है।

User-Agent और HTTP हेडर सेट करना

Headless-ब्राउज़र पुराने या अवास्तविक User-Agent स्ट्रिंग्स का उपयोग करते हैं। उदाहरण के लिए, Puppeteer डिफ़ॉल्ट रूप से User-Agent में "HeadlessChrome" शब्द जोड़ता है। इसके अलावा, सामान्य ब्राउज़रों के अनुरोधों में मौजूद अतिरिक्त हेडर्स को सेट करना आवश्यक है।

छिपाने के लिए प्रासंगिक User-Agent

वास्तविक ब्राउज़रों के ताज़ा User-Agent का उपयोग करें। यहाँ 2024 के लिए कुछ उदाहरण हैं:

# Windows 10 पर Chrome 120
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

# macOS पर Chrome 120
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

# Windows पर Firefox 121
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0

Selenium में हेडर सेट करना

from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')

# CDP के माध्यम से अतिरिक्त हेडर
driver.execute_cdp_cmd('Network.setUserAgentOverride', {
    "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    "platform": 'Win32',
    "acceptLanguage": 'en-US,en;q=0.9'
})

Puppeteer में हेडर सेट करना

await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');

await page.setExtraHTTPHeaders({
    'Accept-Language': 'en-US,en;q=0.9',
    'Accept-Encoding': 'gzip, deflate, br',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Sec-Fetch-Site': 'none',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-User': '?1',
    'Sec-Fetch-Dest': 'document'
});

Sec-Fetch-* हेडर्स अत्यंत महत्वपूर्ण हैं — ये Chrome 76+ में आए हैं और इनकी अनुपस्थिति पुराने ब्राउज़रों या बॉट्स को उजागर करती है।

Canvas और WebGL फ़िंगरप्रिंट का अनुकरण

Canvas और WebGL फ़िंगरप्रिंटिंग एक शक्तिशाली डिटेक्शन विधि है, क्योंकि headless-ब्राउज़र समान फ़िंगरप्रिंट उत्पन्न करते हैं। एंटी-बॉट सिस्टम एक अदृश्य Canvas बनाते हैं, उस पर टेक्स्ट बनाते हैं और पिक्सल का हैश निकालते हैं। यदि हजारों अनुरोधों का हैश समान है — तो ये बॉट्स हैं।

Canvas में शोर जोड़ना

निम्नलिखित स्क्रिप्ट Canvas फ़िंगरप्रिंट में यादृच्छिक शोर जोड़ती है, जिससे प्रत्येक अनुरोध अद्वितीय हो जाता है:

await page.evaluateOnNewDocument(() => {
    const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
    const originalToBlob = HTMLCanvasElement.prototype.toBlob;
    const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
    
    // शोर जोड़ने का फ़ंक्शन
    const addNoise = (canvas, context) => {
        const imageData = originalGetImageData.call(context, 0, 0, canvas.width, canvas.height);
        for (let i = 0; i < imageData.data.length; i += 4) {
            imageData.data[i] += Math.floor(Math.random() * 10) - 5;
            imageData.data[i + 1] += Math.floor(Math.random() * 10) - 5;
            imageData.data[i + 2] += Math.floor(Math.random() * 10) - 5;
        }
        context.putImageData(imageData, 0, 0);
    };
    
    HTMLCanvasElement.prototype.toDataURL = function() {
        addNoise(this, this.getContext('2d'));
        return originalToDataURL.apply(this, arguments);
    };
});

WebGL पैरामीटर का अनुकरण

WebGL ग्राफिक्स कार्ड और ड्राइवरों के बारे में जानकारी प्रकट करता है। Headless मोड में ये पैरामीटर सॉफ़्टवेयर रेंडरिंग का संकेत देते हैं:

await page.evaluateOnNewDocument(() => {
    const getParameter = WebGLRenderingContext.prototype.getParameter;
    WebGLRenderingContext.prototype.getParameter = function(parameter) {
        // असली ग्राफिक्स कार्ड का अनुकरण
        if (parameter === 37445) {
            return 'Intel Inc.';
        }
        if (parameter === 37446) {
            return 'Intel Iris OpenGL Engine';
        }
        return getParameter.call(this, parameter);
    };
});

पैरामीटर 37445 UNMASKED_VENDOR_WEBGL है, और 37446 UNMASKED_RENDERER_WEBGL है। Headless मोड में ये "Google SwiftShader" लौटाते हैं, जो स्वचालन को उजागर करता है।

Selenium Stealth: Python के लिए तैयार समाधान

selenium-stealth पुस्तकालय स्वचालित रूप से Selenium को छिपाने के लिए दर्जनों पैच लागू करता है। यह Python डेवलपर्स के लिए सबसे सरल समाधान है, जो प्रत्येक पैरामीटर की मैन्युअल सेटिंग की आवश्यकता नहीं है।

स्थापना और बुनियादी सेटिंग

pip install selenium-stealth

from selenium import webdriver
from selenium_stealth import stealth
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument("--headless")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(options=options)

# Stealth पैच लागू करना
stealth(driver,
    languages=["en-US", "en"],
    vendor="Google Inc.",
    platform="Win32",
    webgl_vendor="Intel Inc.",
    renderer="Intel Iris OpenGL Engine",
    fix_hairline=True,
)

driver.get("https://bot.sannysoft.com")
driver.save_screenshot("test.png")

पुस्तकालय स्वचालित रूप से navigator.webdriver को हटा देता है, window.chrome जोड़ता है, प्लगइन्स का अनुकरण करता है, WebGL को छिपाता है और 20+ पैच लागू करता है। यह 80% डिटेक्शन मामलों को कवर करता है।

प्रॉक्सी के साथ उन्नत सेटिंग

पूर्ण छिपाने के लिए, selenium-stealth को रिज़िडेंट प्रॉक्सी के साथ संयोजित करें — ये घरेलू उपयोगकर्ताओं के वास्तविक IP पते प्रदान करते हैं, जो उन्नत एंटी-बॉट सिस्टम को बायपास करने के लिए महत्वपूर्ण है:

from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "ip:port"
proxy.ssl_proxy = "ip:port"

capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)

driver = webdriver.Chrome(desired_capabilities=capabilities, options=options)
stealth(driver, languages=["en-US", "en"], vendor="Google Inc.", platform="Win32")

Puppeteer Extra Stealth Plugin для Node.js

Puppeteer के लिए puppeteer-extra-plugin-stealth नामक एक प्लगइन है, जो JavaScript पारिस्थितिकी तंत्र में headless-ब्राउज़रों को छिपाने के लिए सबसे उन्नत समाधान है। इसमें 23 स्वतंत्र मॉड्यूल हैं, जिनमें से प्रत्येक स्वचालन के एक विशेष पहलू को छिपाता है।

स्थापना और बुनियादी उपयोग

npm install puppeteer-extra puppeteer-extra-plugin-stealth

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

(async () => {
    const browser = await puppeteer.launch({ 
        headless: true,
        args: ['--no-sandbox', '--disable-setuid-sandbox']
    });
    
    const page = await browser.newPage();
    await page.goto('https://bot.sannysoft.com');
    await page.screenshot({ path: 'test.png' });
    await browser.close();
})();

Stealth Plugin क्या छिपाता है

प्लगइन स्वचालित रूप से निम्नलिखित पैच लागू करता है:

navigator.webdriver को हटाना
window.chrome ऑब्जेक्ट जोड़ना
navigator.permissions API का अनुकरण
navigator.plugins और navigator.mimeTypes को छिपाना
Canvas और WebGL फ़िंगरप्रिंट का अनुकरण
User-Agent और भाषाओं को छिपाना
iframe contentWindow में विसंगतियों को ठीक करना
Battery API, Media Devices, WebRTC का अनुकरण

प्रॉक्सी और अतिरिक्त पैरामीटर के साथ सेटिंग

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
const AdblockerPlugin = require('puppeteer-extra-plugin-adblocker');

puppeteer.use(StealthPlugin());
puppeteer.use(AdblockerPlugin({ blockTrackers: true }));

(async () => {
    const browser = await puppeteer.launch({
        headless: true,
        args: [
            '--proxy-server=http://your-proxy:port',
            '--disable-web-security',
            '--disable-features=IsolateOrigins,site-per-process'
        ]
    });
    
    const page = await browser.newPage();
    
    // प्रॉक्सी प्रमाणीकरण
    await page.authenticate({
        username: 'your-username',
        password: 'your-password'
    });
    
    await page.setViewport({ width: 1920, height: 1080 });
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });
})();

Playwright: एंटी-डिटेक्शन सेटअप

Playwright की आर्किटेक्चर Puppeteer की तुलना में अधिक उन्नत है और यह स्वचालन के कम निशान छोड़ता है। हालाँकि, उन्नत एंटी-बॉट सिस्टम को बायपास करने के लिए अतिरिक्त सेटिंग्स की आवश्यकता होती है। Playwright के लिए एक stealth प्लगइन का पोर्ट है — playwright-extra.

playwright-extra की स्थापना

npm install playwright-extra playwright-extra-plugin-stealth playwright

const { chromium } = require('playwright-extra');
const stealth = require('playwright-extra-plugin-stealth');

chromium.use(stealth());

(async () => {
    const browser = await chromium.launch({ headless: true });
    const context = await browser.newContext({
        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        viewport: { width: 1920, height: 1080 },
        locale: 'en-US',
        timezoneId: 'America/New_York'
    });
    
    const page = await context.newPage();
    await page.goto('https://bot.sannysoft.com');
    await page.screenshot({ path: 'test.png' });
    await browser.close();
})();

अधिकतम छिपाने के लिए ब्राउज़र संदर्भ सेट करना

Playwright व्यक्तिगत सेटिंग्स के साथ अलग-अलग ब्राउज़र संदर्भ बनाने की अनुमति देता है। यह मल्टी-खाता प्रबंधन या समानांतर पार्सिंग के लिए उपयोगी है:

const context = await browser.newContext({
    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
    viewport: { width: 1440, height: 900 },
    locale: 'en-US',
    timezoneId: 'America/Los_Angeles',
    permissions: ['geolocation'],
    geolocation: { latitude: 37.7749, longitude: -122.4194 },
    colorScheme: 'light',
    deviceScaleFactor: 2,
    isMobile: false,
    hasTouch: false,
    // संदर्भ के लिए प्रॉक्सी सेट करना
    proxy: {
        server: 'http://your-proxy:port',
        username: 'user',
        password: 'pass'
    }
});

geolocation और timezoneId पैरामीटर को प्रॉक्सी के IP पते से मेल खाना चाहिए, अन्यथा एंटी-बॉट सिस्टम विसंगति का पता लगाएंगे (उदाहरण के लिए, कैलिफ़ोर्निया से IP, लेकिन न्यूयॉर्क का टाइमज़ोन)।

ब्लॉकिंग के जोखिम को कम करने के लिए प्रॉक्सी रोटेशन

यहां तक कि एकदम सही तरीके से छिपाया गया headless-ब्राउज़र भी तब ब्लॉक किया जा सकता है जब वह सैकड़ों अनुरोधों के लिए एक ही IP पता का उपयोग करता है। आधुनिक एंटी-बॉट सिस्टम एक ही IP से अनुरोधों की आवृत्ति का विश्लेषण करते हैं और संदिग्ध गतिविधियों को ब्लॉक करते हैं। प्रॉक्सी रोटेशन पार्सिंग के दौरान सुरक्षा का एक अनिवार्य तत्व है।

पार्सिंग के लिए प्रॉक्सी के प्रकार: तुलना

प्रॉक्सी का प्रकार	गति	Trust Score	के लिए बेहतर
Datacenter	बहुत उच्च (50-200 मि.सेक)	कम	सरल वेबसाइटें, बड़े पैमाने पर पार्सिंग
रिज़िडेंट	मध्यम (300-1000 मि.सेक)	उच्च	सुरक्षित वेबसाइटें, सोशल मीडिया
मोबाइल	कम (500-2000 मि.सेक)	बहुत उच्च	मोबाइल ऐप्स, Instagram, TikTok

सुरक्षित वेबसाइटों (मार्केटप्लेस, सोशल मीडिया, विज्ञापन प्लेटफार्म) के लिए पार्सिंग के लिए रिज़िडेंट प्रॉक्सी की सिफारिश की जाती है, क्योंकि उनके पास घरेलू उपयोगकर्ताओं के वास्तविक IP होते हैं और ये एंटी-बॉट सिस्टम की काली सूचियों में नहीं आते हैं।

Puppeteer में प्रॉक्सी रोटेशन का कार्यान्वयन

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const proxyList = [
    'http://user1:pass1@proxy1:port',
    'http://user2:pass2@proxy2:port',
    'http://user3:pass3@proxy3:port'
];

async function scrapeWithRotation(urls) {
    for (let i = 0; i < urls.length; i++) {
        const proxy = proxyList[i % proxyList.length];
        
        const browser = await puppeteer.launch({
            headless: true,
            args: [`--proxy-server=${proxy}`]
        });
        
        const page = await browser.newPage();
        
        try {
            await page.goto(urls[i], { waitUntil: 'networkidle2' });
            const data = await page.evaluate(() => document.body.innerText);
            console.log(data);
        } catch (error) {
            console.error(`Error on ${urls[i]}:`, error);
        } finally {
            await browser.close();
        }
        
        // अनुरोधों के बीच देरी
        await new Promise(resolve => setTimeout(resolve, 2000));
    }
}

scrapeWithRotation([
    'https://example1.com',
    'https://example2.com',
    'https://example3.com'
]);

सत्र-आधारित प्रॉक्सी के माध्यम से रोटेशन

कुछ प्रॉक्सी प्रदाता (जिनमें ProxyCove शामिल हैं) सत्र-आधारित रोटेशन की पेशकश करते हैं — प्रत्येक अनुरोध स्वचालित रूप से नया IP प्राप्त करता है बिना ब्राउज़र को पुनः आरंभ किए। यह प्रॉक्सी के विशेष URL प्रारूप के माध्यम से कार्यान्वित होता है:

// प्रारूप: username-session-RANDOM:password@gateway:port
const generateSessionProxy = () => {
    const sessionId = Math.random().toString(36).substring(7);
    return `http://username-session-${sessionId}:password@gateway.proxycove.com:12321`;
};

const browser = await puppeteer.launch({
    args: [`--proxy-server=${generateSessionProxy()}`]
});

कैसे जांचें कि छिपाने की गुणवत्ता: परीक्षण उपकरण

छिपाने की सेटिंग के बाद, यह जांचना आवश्यक है कि आपका headless-ब्राउज़र सामान्य उपयोगकर्ता की कितनी अच्छी तरह नकल करता है। कई विशेषीकृत वेबसाइटें हैं जो ब्राउज़र के सैकड़ों पैरामीटर का विश्लेषण करती हैं और दिखाती हैं कि स्वचालन के कौन से निशान बचे हैं।

प्रमुख परीक्षण उपकरण

bot.sannysoft.com — 15+ डिटेक्शन पैरामीटर की जांच करता है, जिसमें webdriver, Chrome ऑब्जेक्ट, प्लगइन्स, Canvas शामिल हैं
arh.antoinevastel.com/bots/areyouheadless — headless Chrome का डिटेक्शन करने में विशेषज्ञता
pixelscan.net — सभी पैरामीटर के दृश्य के साथ उन्नत फ़िंगरप्रिंट विश्लेषण
abrahamjuliot.github.io/creepjs — सबसे विस्तृत विश्लेषण (200+ पैरामीटर), ब्राउज़र के विश्वास स्तर को दिखाता है
iphey.com — प्रॉक्सी और VPN के लिए IP पते की जांच

परीक्षण स्वचालन

सेटिंग में प्रत्येक परिवर्तन के बाद छिपाने की स्वचालित जांच के लिए एक स्क्रिप्ट बनाएं:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

async function testStealth() {
    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    
    // परीक्षण 1: Sannysoft
    await page.goto('https://bot.sannysoft.com');
    await page.screenshot({ path: 'test-sannysoft.png', fullPage: true });
    
    // परीक्षण 2: क्या आप headless हैं
    await page.goto('https://arh.antoinevastel.com/bots/areyouheadless');
    const headlessDetected = await page.evaluate(() => {
        return document.body.innerText.includes('You are not Chrome headless');
    });
    console.log('Headless का पता चला:', !headlessDetected);
    
    // परीक्षण 3: Webdriver प्रॉपर्टी
    const webdriverPresent = await page.evaluate(() => navigator.webdriver);
    console.log('navigator.webdriver:', webdriverPresent);
    
    // परीक्षण 4: Chrome ऑब्जेक्ट
    const chromePresent = await page.evaluate(() => !!window.chrome);
    console.log('window.chrome मौजूद है:', chromePresent);
    
    await browser.close();
}

testStealth();

सफल छिपाने की चेकलिस्ट

आपका headless-ब्राउज़र सही तरीके से छिपा हुआ है, यदि:

navigator.webdriver undefined लौटाता है
window.chrome मौजूद है और runtime ऑब्जेक्ट है
navigator.plugins.length 0 से अधिक है
WebGL विक्रेता और रेंडरर असली ग्राफिक्स कार्ड दिखाते हैं, न कि SwiftShader
Canvas फ़िंगरप्रिंट प्रत्येक सत्र के लिए अद्वितीय है
User-Agent वर्तमान Chrome/Firefox संस्करण के अनुरूप है
प्रॉक्सी का IP पता काली सूचियों में नहीं है (iphey.com के माध्यम से जांच)
Timezone और locale IP पते के भू-स्थान के अनुरूप हैं

निष्कर्ष

Headless-ब्राउज़रों को छिपाना एक जटिल कार्य है, जिसमें दर्जनों पैरामीटर पर ध्यान देने की आवश्यकता होती है। आधुनिक एंटी-बॉट सिस्टम मशीन लर्निंग का उपयोग करते हैं और एक साथ सैकड़ों ब्राउज़र विशेषताओं का विश्लेषण करते हैं, इसलिए केवल User-Agent को बदलना अब काम नहीं करता। सफल पार्सिंग के लिए कई सुरक्षा तरीकों को संयोजित करना आवश्यक है।

प्रभावी छिपाने के मुख्य तत्व: स्वचालन के JavaScript मार्करों (navigator.webdriver, CDP वेरिएबल्स) को हटाना, Canvas और WebGL फ़िंगरप्रिंट का अनुकरण, यथार्थवादी HTTP हेडर सेट करना और गुणवत्ता प्रॉक्सी का उपयोग करना। तैयार समाधान (Python के लिए selenium-stealth, Node.js के लिए puppeteer-extra-plugin-stealth) 80% मामलों को कवर करते हैं, लेकिन उन्नत सुरक्षा को बायपास करने के लिए अतिरिक्त सेटिंग्स की आवश्यकता होती है।

एक महत्वपूर्ण बिंदु — प्रॉक्सी का चयन। यहां तक कि एकदम सही तरीके से छिपाया गया ब्राउज़र भी तब ब्लॉक किया जाएगा जब वह काली सूचियों में शामिल IP पते का उपयोग करता है या एक ही IP से बहुत अधिक अनुरोध करता है। सुरक्षित वेबसाइटों के लिए पार्सिंग के लिए हम रिज़िडेंट प्रॉक्सी के साथ स्वचालित रोटेशन का उपयोग करने की सिफारिश करते हैं — ये उच्च ट्रस्ट स्कोर और न्यूनतम ब्लॉकिंग जोखिम प्रदान करते हैं, क्योंकि ये घरेलू उपयोगकर्ताओं के वास्तविक IP का उपयोग करते हैं, न कि सर्वर के पते।

नियमित रूप से छिपाने की गुणवत्ता का परीक्षण विशेष सेवाओं (bot.sannysoft.com, pixelscan.net) के माध्यम से करें और एंटी-बॉट सिस्टम में परिवर्तनों के अनुसार सेटिंग्स को अनुकूलित करें। पार्सिंग एक निरंतर शस्त्रागार की दौड़ है, जो बॉट डेवलपर्स और सुरक्षा निर्माताओं के बीच होती है, इसलिए जो कॉन्फ़िगरेशन आज काम करता है, वह कुछ महीनों में अपडेट की आवश्यकता हो सकती है।

```

हेडलैस ब्राउज़र डिटेक्शन को पार करने के तरीके: सेलेनियम और पपेटियर की मास्किंग