पुपीटियर और प्लेयराइट के साथ प्रॉक्सी का एकीकरण: कोड उदाहरणों के साथ पूर्ण गाइड

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

हेडलेस ब्राउज़रों में प्रॉक्सी का मूल कार्य

Puppeteer और Playwright DevTools प्रोटोकॉल के माध्यम से वास्तविक ब्राउज़रों (Chromium, Firefox, WebKit) को नियंत्रित करते हैं। इसका मतलब है कि प्रॉक्सी ब्राउज़र के लॉन्च स्तर पर सेट किया जाता है, न कि अलग-अलग अनुरोधों पर। दोनों उपकरण HTTP, HTTPS और SOCKS5 प्रॉक्सी का समर्थन करते हैं, लेकिन उनके सेटअप के लिए अलग-अलग API हैं।

सामान्य HTTP पुस्तकालयों (axios, fetch) से मुख्य अंतर:

• प्रॉक्सी ब्राउज़र के लॉन्च पर सेट किया जाता है — एक ब्राउज़र सत्र के भीतर प्रॉक्सी को तुरंत नहीं बदला जा सकता
• JavaScript का समर्थन और रेंडरिंग — प्रॉक्सी सभी पृष्ठ संसाधनों (छवियाँ, स्क्रिप्ट, XHR) पर लागू होती है
• स्वचालित रीडायरेक्ट और कुकीज़ का प्रबंधन — ब्राउज़र वास्तविक उपयोगकर्ता की तरह व्यवहार करता है
• फिंगरप्रिंटिंग — प्रॉक्सी के साथ भी, साइटें ब्राउज़र की विशेषताओं के आधार पर स्वचालन का पता लगा सकती हैं

Puppeteer में प्रॉक्सी सेटअप

Puppeteer — Google द्वारा Chrome/Chromium को नियंत्रित करने के लिए एक पुस्तकालय है। प्रॉक्सी को ब्राउज़र के लॉन्च तर्कों के माध्यम से --proxy-server फ्लैग का उपयोग करके सेट किया जाता है।

HTTP/HTTPS प्रॉक्सी का मूल सेटअप

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    headless: true,
    args: [
      '--proxy-server=http://proxy.example.com:8080'
    ]
  });

  const page = await browser.newPage();
  
  // IP पते की जांच
  await page.goto('https://api.ipify.org?format=json');
  const content = await page.content();
  console.log('वर्तमान IP:', content);

  await browser.close();
})();

यह कोड प्रॉक्सी सर्वर के माध्यम से ब्राउज़र लॉन्च करता है। सभी HTTP और HTTPS अनुरोध निर्दिष्ट प्रॉक्सी के माध्यम से जाएंगे। कार्यक्षमता की जांच के लिए ipify सेवा का उपयोग किया जाता है, जो बाहरी IP पता लौटाती है।

SOCKS5 प्रॉक्सी का सेटअप

const browser = await puppeteer.launch({
  headless: true,
  args: [
    '--proxy-server=socks5://proxy.example.com:1080'
  ]
});

// बाकी कोड समान है

SOCKS5 प्रॉक्सी निम्न स्तर पर काम करते हैं और UDP ट्रैफ़िक का समर्थन करते हैं, जो कुछ वेब अनुप्रयोगों के लिए उपयोगी हो सकता है। सिंटैक्स HTTP प्रॉक्सी के समान है, केवल URL में प्रोटोकॉल बदलता है।

विशिष्ट डोमेन के लिए प्रॉक्सी का उपयोग करना

const browser = await puppeteer.launch({
  args: [
    '--proxy-server=http://proxy1.example.com:8080',
    '--proxy-bypass-list=localhost;127.0.0.1;*.internal.com'
  ]
});

// स्थानीय अनुरोध और *.internal.com के लिए अनुरोध सीधे जाएंगे
// सभी अन्य — प्रॉक्सी के माध्यम से

--proxy-bypass-list फ्लैग कुछ डोमेन को प्रॉक्सीकरण से बाहर करने की अनुमति देता है। यह तब उपयोगी होता है जब सीधे और प्रॉक्सी अनुरोधों को संयोजित करने की आवश्यकता होती है।

Playwright में प्रॉक्सी सेटअप

Playwright — Microsoft द्वारा विकसित एक अधिक आधुनिक पुस्तकालय है, जो Chromium, Firefox और WebKit का समर्थन करता है। प्रॉक्सी को कॉन्फ़िगरेशन ऑब्जेक्ट के माध्यम से सेट किया जाता है, जो API को अधिक स्पष्ट और टाइप किया गया बनाता है।

प्रॉक्सी का मूल सेटअप

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

(async () => {
  const browser = await chromium.launch({
    proxy: {
      server: 'http://proxy.example.com:8080'
    }
  });

  const context = await browser.newContext();
  const page = await context.newPage();
  
  await page.goto('https://api.ipify.org?format=json');
  const ip = await page.textContent('body');
  console.log('प्रॉक्सी के माध्यम से IP:', ip);

  await browser.close();
})();

Playwright proxy ऑब्जेक्ट का उपयोग करता है, न कि कमांड लाइन तर्कों का। यह TypeScript में बेहतर टाइपिंग और अधिक साफ कोड सुनिश्चित करता है।

संदर्भ स्तर पर प्रॉक्सी सेटअप

const browser = await chromium.launch();

// संदर्भ 1 - प्रॉक्सी के साथ
const context1 = await browser.newContext({
  proxy: {
    server: 'http://proxy1.example.com:8080'
  }
});

// संदर्भ 2 - दूसरे प्रॉक्सी के साथ
const context2 = await browser.newContext({
  proxy: {
    server: 'http://proxy2.example.com:8080'
  }
});

const page1 = await context1.newPage();
const page2 = await context2.newPage();

// प्रत्येक पृष्ठ अपनी प्रॉक्सी का उपयोग करता है!

Playwright का एक प्रमुख लाभ यह है कि एक ही प्रक्रिया के भीतर विभिन्न प्रॉक्सी के साथ कई ब्राउज़र संदर्भ बनाए जा सकते हैं। यह कई IP पते के साथ काम करते समय संसाधनों की बचत करता है।

प्रॉक्सीकरण से डोमेन को बाहर करना

const browser = await chromium.launch({
  proxy: {
    server: 'http://proxy.example.com:8080',
    bypass: 'localhost,127.0.0.1,*.internal.com'
  }
});

// localhost और *.internal.com के लिए अनुरोध सीधे जाएंगे

लॉगिन और पासवर्ड द्वारा प्रमाणीकरण

अधिकांश व्यावसायिक प्रॉक्सी प्रमाणीकरण की आवश्यकता होती है। दोनों उपकरण प्रमाणीकरण का समर्थन करते हैं, लेकिन इसे अलग-अलग तरीके से लागू करते हैं।

Puppeteer में प्रमाणीकरण

const browser = await puppeteer.launch({
  args: ['--proxy-server=http://proxy.example.com:8080']
});

const page = await browser.newPage();

// प्रॉक्सी के लिए क्रेडेंशियल सेट करें
await page.authenticate({
  username: 'your_username',
  password: 'your_password'
});

await page.goto('https://httpbin.org/ip');
const content = await page.content();
console.log(content);

page.authenticate() विधि इस पृष्ठ पर सभी बाद के अनुरोधों के लिए क्रेडेंशियल सेट करती है। इसे पहले page.goto() से पहले कॉल करना महत्वपूर्ण है।

Playwright में प्रमाणीकरण

const browser = await chromium.launch({
  proxy: {
    server: 'http://proxy.example.com:8080',
    username: 'your_username',
    password: 'your_password'
  }
});

const page = await browser.newPage();
await page.goto('https://httpbin.org/ip');

Playwright प्रॉक्सी कॉन्फ़िगरेशन ऑब्जेक्ट में सीधे क्रेडेंशियल निर्दिष्ट करने की अनुमति देता है — यह अधिक सुविधाजनक और सुरक्षित है, क्योंकि इसमें अतिरिक्त विधियों को कॉल करने की आवश्यकता नहीं होती है।

वैकल्पिक तरीका: URL में क्रेडेंशियल

// दोनों फ्रेमवर्क में काम करता है
const proxyUrl = 'http://username:password@proxy.example.com:8080';

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

// Playwright
const browser = await chromium.launch({
  proxy: { server: proxyUrl }
});

यह तरीका काम करता है, लेकिन उत्पादन के लिए अनुशंसित नहीं है — क्रेडेंशियल लॉग में जा सकते हैं। संवेदनशील डेटा को स्टोर करने के लिए पर्यावरण चर का उपयोग करें।

प्रॉक्सी रोटेशन और IP पूल प्रबंधन

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

प्रॉक्सी सूची के साथ सरल रोटेशन (Puppeteer)

const puppeteer = require('puppeteer');

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

async function scrapeWithRotation(urls) {
  for (let i = 0; i < urls.length; i++) {
    const proxyUrl = proxyList[i % proxyList.length];
    
    const browser = await puppeteer.launch({
      args: [`--proxy-server=${proxyUrl}`]
    });

    try {
      const page = await browser.newPage();
      await page.goto(urls[i], { waitUntil: 'networkidle0' });
      
      const data = await page.evaluate(() => {
        return {
          title: document.title,
          url: window.location.href
        };
      });
      
      console.log(`URL ${i + 1}:`, data);
    } catch (error) {
      console.error(`त्रुटि ${urls[i]} पर:`, error.message);
    } finally {
      await browser.close();
    }
  }
}

const urlsToScrape = [
  'https://example.com/page1',
  'https://example.com/page2',
  'https://example.com/page3',
  'https://example.com/page4'
];

scrapeWithRotation(urlsToScrape);

यह कोड सूची से प्रॉक्सी को चक्रीय रूप से पार करता है और प्रत्येक URL के लिए नया ब्राउज़र लॉन्च करता है। i % proxyList.length विधि चक्रीय रोटेशन सुनिश्चित करती है।

संदर्भ पूल के साथ रोटेशन (Playwright)

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

const proxyList = [
  { server: 'http://proxy1.example.com:8080', username: 'user1', password: 'pass1' },
  { server: 'http://proxy2.example.com:8080', username: 'user2', password: 'pass2' },
  { server: 'http://proxy3.example.com:8080', username: 'user3', password: 'pass3' }
];

async function scrapeWithContextPool(urls) {
  const browser = await chromium.launch();
  
  // विभिन्न प्रॉक्सी के साथ संदर्भों का पूल बनाना
  const contexts = await Promise.all(
    proxyList.map(proxy => browser.newContext({ proxy }))
  );

  for (let i = 0; i < urls.length; i++) {
    const context = contexts[i % contexts.length];
    const page = await context.newPage();
    
    try {
      await page.goto(urls[i], { waitUntil: 'networkidle' });
      const title = await page.title();
      console.log(`URL ${i + 1} (प्रॉक्सी ${i % contexts.length}):`, title);
    } catch (error) {
      console.error(`त्रुटि ${urls[i]} पर:`, error.message);
    } finally {
      await page.close();
    }
  }

  await browser.close();
}

const urls = [
  'https://example.com/page1',
  'https://example.com/page2',
  'https://example.com/page3'
];

scrapeWithContextPool(urls);

Playwright एक ही ब्राउज़र में कई संदर्भ बनाने की अनुमति देता है, प्रत्येक अपनी प्रॉक्सी के साथ। यह पूर्ण ब्राउज़र को फिर से शुरू करने की तुलना में मेमोरी और लॉन्च समय की बचत करता है।

त्रुटियों की निगरानी के साथ स्मार्ट रोटेशन

class ProxyRotator {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
    this.failedProxies = new Set();
  }

  getNext() {
    const availableProxies = this.proxyList.filter(
      (_, index) => !this.failedProxies.has(index)
    );

    if (availableProxies.length === 0) {
      throw new Error('सभी प्रॉक्सी अनुपलब्ध हैं');
    }

    const proxy = this.proxyList[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
    
    return { proxy, index: this.currentIndex - 1 };
  }

  markFailed(index) {
    this.failedProxies.add(index);
    console.log(`प्रॉक्सी ${index} को अनुपलब्ध के रूप में चिह्नित किया गया`);
  }

  resetFailed() {
    this.failedProxies.clear();
  }
}

// उपयोग
const rotator = new ProxyRotator(proxyList);

async function scrapeWithSmartRotation(url, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const { proxy, index } = rotator.getNext();
    
    const browser = await chromium.launch({ proxy });
    const page = await browser.newPage();

    try {
      await page.goto(url, { timeout: 30000 });
      const data = await page.content();
      await browser.close();
      return data;
    } catch (error) {
      console.error(`प्रॉक्सी ${index} के साथ त्रुटि:`, error.message);
      rotator.markFailed(index);
      await browser.close();
      
      if (attempt === maxRetries - 1) {
        throw new Error(`किसी भी प्रयास के बाद ${maxRetries} प्रयासों के बाद ${url} लोड करने में असफल`);
      }
    }
  }
}

यह क्लास काम नहीं करने वाली प्रॉक्सी को ट्रैक करता है और उन्हें रोटेशन से बाहर करता है। त्रुटि होने पर स्वचालित रूप से सूची में अगली प्रॉक्सी पर स्विच किया जाता है।

त्रुटि हैंडलिंग और कार्यक्षमता की जांच

प्रॉक्सी के साथ काम करते समय विशिष्ट त्रुटियाँ होती हैं: कनेक्शन टाइमआउट, प्रमाणीकरण में अस्वीकृति, लक्षित साइट द्वारा IP ब्लॉक। त्रुटियों को सही तरीके से संभालना पार्सर के स्थिरता के लिए महत्वपूर्ण है।

सामान्य त्रुटियाँ और उनका हैंडलिंग

async function safePageLoad(page, url, options = {}) {
  const defaultOptions = {
    timeout: 30000,
    waitUntil: 'networkidle0',
    maxRetries: 3,
    retryDelay: 2000
  };

  const config = { ...defaultOptions, ...options };

  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
    try {
      await page.goto(url, {
        timeout: config.timeout,
        waitUntil: config.waitUntil
      });
      
      return { success: true, attempt };
    } catch (error) {
      console.error(`कोशिश ${attempt} असफल रही:`, error.message);

      // त्रुटि के प्रकार का विश्लेषण
      if (error.message.includes('ERR_PROXY_CONNECTION_FAILED')) {
        throw new Error('प्रॉक्सी अनुपलब्ध है');
      }
      
      if (error.message.includes('ERR_TUNNEL_CONNECTION_FAILED')) {
        throw new Error('प्रॉक्सी टनलिंग त्रुटि');
      }

      if (error.message.includes('407')) {
        throw new Error('प्रॉक्सी प्रमाणीकरण त्रुटि (407)');
      }

      if (error.message.includes('Navigation timeout')) {
        console.log(`लोडिंग टाइमआउट, ${config.retryDelay}ms में पुनः प्रयास करें`);
        await new Promise(resolve => setTimeout(resolve, config.retryDelay));
        continue;
      }

      // यदि यह अंतिम प्रयास है - त्रुटि को फेंकें
      if (attempt === config.maxRetries) {
        throw error;
      }
    }
  }
}

प्रॉक्सी की कार्यक्षमता की जांच

async function testProxy(proxyConfig) {
  const browser = await chromium.launch({ proxy: proxyConfig });
  const page = await browser.newPage();

  const result = {
    working: false,
    ip: null,
    responseTime: null,
    error: null
  };

  const startTime = Date.now();

  try {
    await page.goto('https://api.ipify.org?format=json', { timeout: 10000 });
    const content = await page.textContent('body');
    const data = JSON.parse(content);
    
    result.working = true;
    result.ip = data.ip;
    result.responseTime = Date.now() - startTime;
  } catch (error) {
    result.error = error.message;
  } finally {
    await browser.close();
  }

  return result;
}

// प्रॉक्सी सूची का परीक्षण
async function validateProxyList(proxyList) {
  console.log('प्रॉक्सी की जांच...');
  
  const results = await Promise.all(
    proxyList.map(async (proxy, index) => {
      const result = await testProxy(proxy);
      console.log(`प्रॉक्सी ${index + 1}:`, result.working ? `✓ ${result.ip} (${result.responseTime}ms)` : `✗ ${result.error}`);
      return { proxy, ...result };
    })
  );

  const workingProxies = results.filter(r => r.working);
  console.log(`\nकार्यशील प्रॉक्सी: ${workingProxies.length}/${proxyList.length}`);
  
  return workingProxies.map(r => r.proxy);
}

यह फ़ंक्शन उपयोग से पहले प्रत्येक प्रॉक्सी की जांच करता है, प्रतिक्रिया समय को मापता है और केवल कार्यशील प्रॉक्सी लौटाता है। एप्लिकेशन शुरू करते समय मान्यता चलाने की सिफारिश की जाती है।

निगरानी और लॉगिंग

class ProxyMonitor {
  constructor() {
    this.stats = {
      totalRequests: 0,
      successfulRequests: 0,
      failedRequests: 0,
      proxyErrors: 0,
      averageResponseTime: 0,
      requestsByProxy: new Map()
    };
  }

  recordRequest(proxyIndex, success, responseTime, error = null) {
    this.stats.totalRequests++;
    
    if (success) {
      this.stats.successfulRequests++;
      this.stats.averageResponseTime = 
        (this.stats.averageResponseTime * (this.stats.successfulRequests - 1) + responseTime) / 
        this.stats.successfulRequests;
    } else {
      this.stats.failedRequests++;
      if (error && error.includes('proxy')) {
        this.stats.proxyErrors++;
      }
    }

    // प्रत्येक प्रॉक्सी के लिए सांख्यिकी
    if (!this.stats.requestsByProxy.has(proxyIndex)) {
      this.stats.requestsByProxy.set(proxyIndex, { success: 0, failed: 0 });
    }
    
    const proxyStats = this.stats.requestsByProxy.get(proxyIndex);
    success ? proxyStats.success++ : proxyStats.failed++;
  }

  getReport() {
    const successRate = (this.stats.successfulRequests / this.stats.totalRequests * 100).toFixed(2);
    
    return {
      ...this.stats,
      successRate: `${successRate}%`,
      averageResponseTime: `${this.stats.averageResponseTime.toFixed(0)}ms`
    };
  }
}

// उपयोग
const monitor = new ProxyMonitor();

async function monitoredScrape(url, proxyIndex) {
  const startTime = Date.now();
  try {
    // ... पार्सिंग कोड ...
    const responseTime = Date.now() - startTime;
    monitor.recordRequest(proxyIndex, true, responseTime);
  } catch (error) {
    monitor.recordRequest(proxyIndex, false, 0, error.message);
    throw error;
  }
}

उन्नत परिदृश्य: भू-स्थान और फिंगरप्रिंटिंग

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

प्रॉक्सी के लिए भू-स्थान और भाषा सेटअप

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

async function createContextWithGeo(proxy, geoData) {
  const browser = await chromium.launch({ proxy });
  
  const context = await browser.newContext({
    locale: geoData.locale,           // 'en-US', 'de-DE', 'fr-FR'
    timezoneId: geoData.timezone,     // 'America/New_York', 'Europe/Berlin'
    geolocation: {
      latitude: geoData.latitude,
      longitude: geoData.longitude
    },
    permissions: ['geolocation']
  });

  return { browser, context };
}

// उदाहरण: जर्मनी से प्रॉक्सी
const germanyProxy = {
  server: 'http://de-proxy.example.com:8080',
  username: 'user',
  password: 'pass'
};

const germanyGeo = {
  locale: 'de-DE',
  timezone: 'Europe/Berlin',
  latitude: 52.520008,
  longitude: 13.404954
};

const { browser, context } = await createContextWithGeo(germanyProxy, germanyGeo);
const page = await context.newPage();

await page.goto('https://www.google.com');
// Google बर्लिन के लिए परिणामों के साथ जर्मन संस्करण दिखाएगा

यह कोड ब्राउज़र को इस तरह से सेट करता है कि यह जर्मनी के वास्तविक उपयोगकर्ता के रूप में दिखाई दे: इंटरफेस की जर्मन भाषा, बर्लिन का समय क्षेत्र और बर्लिन के केंद्र के निर्देशांक।

फिंगरप्रिंट की पूर्ण सेटिंग

async function createStealthContext(proxy, profile) {
  const context = await chromium.launch({ proxy }).then(b => 
    b.newContext({
      locale: profile.locale,
      timezoneId: profile.timezone,
      userAgent: profile.userAgent,
      viewport: profile.viewport,
      deviceScaleFactor: profile.deviceScaleFactor,
      isMobile: profile.isMobile,
      hasTouch: profile.hasTouch,
      colorScheme: profile.colorScheme,
      geolocation: profile.geolocation,
      permissions: ['geolocation']
    })
  );

  return context;
}

// Windows 10 + अमेरिका से Chrome के लिए प्रोफ़ाइल
const desktopUSProfile = {
  locale: 'en-US',
  timezone: 'America/New_York',
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  viewport: { width: 1920, height: 1080 },
  deviceScaleFactor: 1,
  isMobile: false,
  hasTouch: false,
  colorScheme: 'light',
  geolocation: { latitude: 40.7128, longitude: -74.0060 }
};

// यूके से iPhone के लिए प्रोफ़ाइल
const mobileUKProfile = {
  locale: 'en-GB',
  timezone: 'Europe/London',
  userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
  viewport: { width: 390, height: 844 },
  deviceScaleFactor: 3,
  isMobile: true,
  hasTouch: true,
  colorScheme: 'light',
  geolocation: { latitude: 51.5074, longitude: -0.1278 }
};

फिंगरप्रिंट की समग्र सेटिंग स्वचालन की पहचान की संभावना को कम करती है। यह महत्वपूर्ण है कि सभी पैरामीटर एक-दूसरे के साथ मेल खाते हों: उदाहरण के लिए, मोबाइल User-Agent को मोबाइल स्क्रीन रिज़ॉल्यूशन के साथ जाना चाहिए।

WebRTC लीक को बायपास करना

// Puppeteer: WebRTC को ब्लॉक करना
const browser = await puppeteer.launch({
  args: [
    '--proxy-server=http://proxy.example.com:8080',
    '--disable-webrtc',
    '--disable-webrtc-hw-encoding',
    '--disable-webrtc-hw-decoding'
  ]
});

// Playwright: WebRTC API को ओवरराइड करना
const context = await browser.newContext({ proxy: proxyConfig });

await context.addInitScript(() => {
  // RTCPeerConnection को ब्लॉक करें
  window.RTCPeerConnection = undefined;
  window.RTCDataChannel = undefined;
  window.RTCSessionDescription = undefined;
  
  // getUserMedia को ओवरराइड करें
  navigator.mediaDevices.getUserMedia = undefined;
  navigator.getUserMedia = undefined;
});

WebRTC आपके वास्तविक IP पते को प्रॉक्सी का उपयोग करते समय भी प्रकट कर सकता है। यह कोड ब्राउज़र में WebRTC API को पूरी तरह से बंद कर देता है।

प्रॉक्सी के साथ Puppeteer और Playwright की तुलना

चुनने के लिए सिफारिशें

यदि आप Puppeteer चुनते हैं, तो:

• केवल Chrome/Chromium के साथ काम कर रहे हैं
• एक समय में एक प्रॉक्सी का उपयोग कर रहे हैं
• मौजूदा उपकरणों के साथ अधिकतम संगतता की आवश्यकता है
• पहले से ही Puppeteer पर एक बड़ा कोडबेस है

यदि आप Playwright चुनते हैं, तो:

• Firefox या Safari (WebKit) के साथ काम करने की आवश्यकता है
• एक साथ कई प्रॉक्सी का उपयोग करने की आवश्यकता है
• स्केलिंग के दौरान प्रदर्शन महत्वपूर्ण है
• TypeScript में लिख रहे हैं
• नए प्रोजेक्ट को शून्य से शुरू कर रहे हैं

प्रॉक्सी रोटेशन के दौरान प्रदर्शन

परीक्षण: MacBook Pro M1 पर 10 प्रॉक्सी के रोटेशन के साथ 100 पृष्ठों का पार्सिंग:

संदर्भ पूल के साथ Playwright लगभग 2 गुना तेज है क्योंकि ब्राउज़र को फिर से शुरू करने की कोई ओवरहेड नहीं है। यह हजारों पृष्ठों के पार्सिंग के दौरान महत्वपूर्ण है।

निष्कर्ष

Puppeteer और Playwright के साथ प्रॉक्सी का एकीकरण वेब स्क्रैपिंग, परीक्षण और स्वचालन के लिए मानक प्रथा है। Puppeteer सरलता और व्यापक पारिस्थितिकी तंत्र प्रदान करता है, जबकि Playwright आधुनिक API और ब्राउज़र संदर्भों के माध्यम से कई प्रॉक्सी के साथ काम करने पर बेहतर प्रदर्शन प्रदान करता है।

हमने जिन प्रमुख बिंदुओं पर चर्चा की:

• दोनों फ्रेमवर्क में HTTP, HTTPS और SOCKS5 प्रॉक्सी का मूल सेटअप
• लॉगिन और पासवर्ड द्वारा प्रमाणीकरण
• बड़े पैमाने पर पार्सिंग के लिए प्रॉक्सी रोटेशन
• उपयोग से पहले प्रॉक्सी की त्रुटि हैंडलिंग और मान्यता
• एंटी-बॉट सिस्टम को बायपास करने के लिए भू-स्थान और फिंगरप्रिंटिंग का सेटअप
• विभिन्न दृष्टिकोणों के प्रदर्शन की तुलना

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

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