प्रॉक्सी को API के माध्यम से स्वचालित रूप से बदलना: उदाहरणों के साथ गाइड

```html

सैकड़ों अनुरोधों के साथ काम करते समय मैन्युअल प्रॉक्सी बदलना समय और पैसे की बर्बादी है। API-रोटेशन ब्लॉक होने पर स्वचालित रूप से IP एड्रेस स्विच करने, लोड वितरित करने और पार्सिंग या मल्टी-अकाउंटिंग को स्केल करने की अनुमति देता है। इस गाइड में, हम विभिन्न कार्यों के लिए स्वचालित प्रॉक्सी रोटेशन सेट करने का तरीका समझेंगे: मार्केटप्लेस पार्सिंग से लेकर Facebook Ads में अकाउंट फार्मिंग तक।

यह सामग्री उन डेवलपर्स के लिए उपयुक्त है जो Python या Node.js में पार्सर लिखते हैं, साथ ही API-एकीकरण के साथ तैयार टूल का उपयोग करने वाले आर्बिट्राजर्स के लिए भी।

API के माध्यम से प्रॉक्सी रोटेशन के स्वचालन की आवश्यकता क्यों है

API के माध्यम से IP एड्रेस का स्वचालित रोटेशन कई महत्वपूर्ण कार्यों को हल करता है, जिनका सामना विभिन्न क्षेत्रों के विशेषज्ञों को करना पड़ता है:

मार्केटप्लेस और वेबसाइटों की पार्सिंग के लिए: Wildberries, Ozon या Avito से डेटा एकत्र करते समय प्रत्येक IP सीमित संख्या में अनुरोध कर सकता है (आमतौर पर प्रति घंटे 50-200)। API-रोटेशन सीमा तक पहुंचने या कैप्चा प्राप्त होने पर स्वचालित रूप से नए IP पर स्विच करने की अनुमति देता है, जिससे निरंतर डेटा संग्रह सुनिश्चित होता है।

आर्बिट्राज और मल्टी-अकाउंटिंग के लिए: 20-50 Facebook Ads विज्ञापन कैबिनेट या Instagram अकाउंट के साथ काम करते समय प्रत्येक प्रोफ़ाइल को अलग करना आवश्यक है। API Dolphin Anty या AdsPower में प्रत्येक अकाउंट को प्रोग्रामेटिक रूप से अद्वितीय प्रॉक्सी असाइन करने, ब्लॉक होने पर सत्रों को स्वचालित रूप से पुनः बनाने की अनुमति देता है।

SMM स्वचालन के लिए: Instagram, TikTok या VK में बड़े पैमाने पर पोस्टिंग सेवाओं को rate limits से बचने के लिए IP एड्रेस के बीच क्रियाओं को वितरित करना चाहिए। API प्रत्येक सत्र या अकाउंट समूह के लिए गतिशील रूप से नए प्रॉक्सी प्राप्त करने की क्षमता देता है।

मैन्युअल परिवर्तन की तुलना में API-स्वचालन के मुख्य लाभ:

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

विशिष्ट उपयोग परिदृश्य: आप Wildberries पर प्रतिस्पर्धियों की कीमतें पार्स कर रहे हैं। API के बिना आपको मैन्युअल रूप से ब्लॉक को ट्रैक करना होगा, प्रॉक्सी प्रदाता के पैनल में जाना होगा, नया डेटा कॉपी करना होगा, इसे स्क्रिप्ट में पेस्ट करना होगा। API के साथ यह सब स्वचालित रूप से होता है: स्क्रिप्ट को 429 त्रुटि (Too Many Requests) मिलती है, प्रॉक्सी सेवा के API को अनुरोध भेजती है, नया IP प्राप्त करती है और काम जारी रखती है।

प्रॉक्सी रोटेशन के प्रकार: sticky sessions बनाम स्वचालित परिवर्तन

स्वचालन सेट करने से पहले, IP एड्रेस रोटेशन के प्रकारों के बीच अंतर को समझना महत्वपूर्ण है। रणनीति का चुनाव आपके कार्य पर निर्भर करता है।

Sticky Sessions (सत्र प्रॉक्सी)

Sticky sessions का उपयोग करते समय एक IP एड्रेस निश्चित समय (आमतौर पर 5 से 30 मिनट) के लिए आपके सत्र से जुड़ा रहता है। परिवर्तन केवल सत्र समय समाप्त होने के बाद या आपके API-अनुरोध पर होता है।

कब उपयोग करें:

सोशल नेटवर्क में अकाउंट के साथ काम (Instagram, Facebook) — बार-बार IP बदलना संदेह पैदा करता है
बहु-पृष्ठ फॉर्म भरना, जहां सत्र बनाए रखना आवश्यक है
सत्र के दौरान किसी विशिष्ट क्षेत्र से विज्ञापन परीक्षण
प्रमाणीकरण वाली साइटों की पार्सिंग, जहां IP बदलने से लॉगआउट हो जाएगा

Sticky session बनाने के लिए API-अनुरोध का उदाहरण (आमतौर पर विशेष लॉगिन प्रारूप का उपयोग किया जाता है):

// प्रारूप: username-session-SESSIONID:password
// SESSIONID — कोई भी स्ट्रिंग, समान = एक IP

proxy = "username-session-abc123:password@gate.proxycove.com:8000"

// session-abc123 के साथ सभी अनुरोध सत्र के समय के लिए एक IP प्राप्त करेंगे
// नए IP के लिए दूसरा SESSIONID उपयोग करें: session-xyz789

प्रत्येक अनुरोध पर स्वचालित रोटेशन

प्रॉक्सी सर्वर से प्रत्येक नए कनेक्शन पर IP एड्रेस बदलता है। यह सत्र पैरामीटर निर्दिष्ट किए बिना रेजिडेंशियल प्रॉक्सी का मानक व्यवहार है।

कब उपयोग करें:

प्रमाणीकरण के बिना बड़े पैमाने पर पार्सिंग (कीमतें, संपर्क, विज्ञापन)
सार्वजनिक API पर आक्रामक rate limits को बायपास करना
उन साइटों से डेटा संग्रह जो 10-20 अनुरोधों के बाद IP को बैन कर देती हैं
विभिन्न क्षेत्रों से सामग्री की उपलब्धता की जांच

Python में उपयोग का उदाहरण (प्रत्येक अनुरोध = नया IP):

import requests

proxy = {
    "http": "http://username:password@gate.proxycove.com:8000",
    "https": "http://username:password@gate.proxycove.com:8000"
}

# प्रत्येक अनुरोध नया IP प्राप्त करेगा
for i in range(10):
    response = requests.get("https://api.ipify.org", proxies=proxy)
    print(f"अनुरोध {i+1}, IP: {response.text}")

टाइमर द्वारा रोटेशन

आप प्रोग्रामेटिक रूप से नियंत्रित करते हैं कि IP कब बदलना है: हर N मिनट, M अनुरोधों के बाद या विशिष्ट त्रुटियां प्राप्त होने पर। यह एक हाइब्रिड दृष्टिकोण है, जो प्रॉक्सी सेवा के API के माध्यम से लागू किया जाता है।

कब उपयोग करें:

ट्रैफ़िक खपत का अनुकूलन — केवल आवश्यकता पड़ने पर परिवर्तन
उन साइटों के साथ काम करना जो पैटर्न ट्रैक करती हैं (बहुत बार-बार बदलना = बैन)
गुमनामी और सत्र स्थिरता के बीच संतुलन

रोटेशन प्रकार	IP परिवर्तन की आवृत्ति	कार्य	ट्रैफ़िक खपत
Sticky Session	5-30 मिनट	मल्टी-अकाउंटिंग, प्रमाणीकरण	कम
ऑटो-रोटेशन	प्रत्येक अनुरोध	पार्सिंग, rate limits बायपास	मध्यम
टाइमर द्वारा	कॉन्फ़िगर करने योग्य	सार्वभौमिक	अनुकूलित

प्रॉक्सी सेवाओं के API के साथ काम करने की मूल बातें

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

प्रॉक्सी सेवाओं के विशिष्ट API-मेथड

हालांकि प्रत्येक प्रदाता का अपना दस्तावेज़ीकरण होता है, मानक मेथड में आमतौर पर शामिल हैं:

GET /api/v1/proxy/list — देश, प्रकार द्वारा फ़िल्टरिंग के साथ उपलब्ध प्रॉक्सी की सूची प्राप्त करें
POST /api/v1/proxy/rotate — सक्रिय सत्र में IP को जबरन बदलें
GET /api/v1/account/balance — बैलेंस पर शेष ट्रैफ़िक या पैसे की जांच करें
GET /api/v1/stats — उपयोग के आंकड़े: ट्रैफ़िक की मात्रा, अनुरोधों की संख्या, त्रुटियां
POST /api/v1/session/create — पैरामीटर (देश, शहर, अवधि) के साथ नया sticky session बनाएं

प्रमाणीकरण आमतौर पर अनुरोध हेडर में API-कुंजी के माध्यम से होता है:

curl -X GET "https://api.provider.com/v1/proxy/list?country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

प्रतिक्रिया आमतौर पर JSON-प्रारूप में आती है:

{
  "status": "success",
  "data": {
    "proxies": [
      {
        "ip": "123.45.67.89",
        "port": 8000,
        "country": "US",
        "city": "New York",
        "protocol": "http",
        "username": "user123",
        "password": "pass456"
      }
    ],
    "total": 150,
    "available": 147
  }
}

API के माध्यम से सत्र प्रबंधन

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

पैरामीटर के साथ सत्र बनाने का उदाहरण:

POST /api/v1/session/create
{
  "country": "US",
  "state": "California",
  "session_duration": 600,  // 10 मिनट
  "session_id": "facebook_account_001"
}

// प्रतिक्रिया:
{
  "status": "success",
  "session": {
    "id": "facebook_account_001",
    "proxy": "gate.provider.com:8000",
    "username": "user-session-facebook_account_001",
    "password": "your_password",
    "ip": "45.67.89.123",
    "expires_at": "2024-01-15T15:30:00Z"
  }
}

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

Python में स्वचालन के उदाहरण: requests, Selenium, Scrapy

Python पार्सिंग और स्वचालन के लिए सबसे लोकप्रिय भाषा है। आइए मुख्य टूल के साथ API-रोटेशन प्रॉक्सी एकीकरण के उदाहरण देखें।

requests में स्वचालित प्रॉक्सी परिवर्तन

requests लाइब्रेरी सरल HTTP-अनुरोधों के लिए उपयोग की जाती है। स्वचालित रोटेशन के लिए एक क्लास-रैपर बनाएंगे, जो त्रुटियों पर प्रॉक्सी बदलता है:

import requests
import random
import time

class RotatingProxySession:
    def __init__(self, proxy_list):
        """
        proxy_list: प्रॉक्सी डेटा के साथ शब्दकोशों की सूची
        [{"http": "http://user:pass@ip:port", "https": "..."}]
        """
        self.proxy_list = proxy_list
        self.current_proxy = None
        self.session = requests.Session()
        self.rotate()
    
    def rotate(self):
        """सूची से यादृच्छिक प्रॉक्सी चुनें"""
        self.current_proxy = random.choice(self.proxy_list)
        self.session.proxies.update(self.current_proxy)
        print(f"प्रॉक्सी पर स्विच किया: {self.current_proxy['http']}")
    
    def get(self, url, max_retries=3, **kwargs):
        """त्रुटियों पर स्वचालित रोटेशन के साथ GET-अनुरोध"""
        for attempt in range(max_retries):
            try:
                response = self.session.get(url, timeout=10, **kwargs)
                
                # यदि ब्लॉक मिला — प्रॉक्सी बदलें
                if response.status_code in [403, 429, 503]:
                    print(f"{response.status_code} मिला, प्रॉक्सी बदल रहे हैं...")
                    self.rotate()
                    time.sleep(2)
                    continue
                
                return response
                
            except requests.exceptions.ProxyError:
                print(f"प्रॉक्सी काम नहीं कर रहा, प्रयास {attempt+1}/{max_retries}")
                self.rotate()
                time.sleep(2)
            
            except requests.exceptions.Timeout:
                print("टाइमआउट, प्रॉक्सी बदल रहे हैं...")
                self.rotate()
                time.sleep(2)
        
        raise Exception(f"{max_retries} प्रयासों के बाद अनुरोध निष्पादित नहीं हो सका")

# उपयोग:
proxies = [
    {"http": "http://user1:pass@gate1.com:8000", "https": "http://user1:pass@gate1.com:8000"},
    {"http": "http://user2:pass@gate2.com:8000", "https": "http://user2:pass@gate2.com:8000"},
]

session = RotatingProxySession(proxies)

# Wildberries पार्स करें
for page in range(1, 50):
    url = f"https://www.wildberries.ru/catalog/page={page}"
    response = session.get(url)
    print(f"पृष्ठ {page}: {response.status_code}")

ब्राउज़र स्वचालन के लिए Selenium के साथ एकीकरण

Selenium का उपयोग JavaScript वाली साइटों की पार्सिंग और ब्राउज़र में क्रियाओं के स्वचालन के लिए किया जाता है। प्रॉक्सी बदलने के लिए ड्राइवर को फिर से बनाना आवश्यक है, क्योंकि प्रॉक्सी सेटिंग्स इनिशियलाइज़ेशन पर सेट की जाती हैं:

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

class SeleniumRotatingProxy:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.driver = None
        self.current_proxy_index = 0
    
    def create_driver(self):
        """वर्तमान प्रॉक्सी के साथ नया ड्राइवर बनाएं"""
        if self.driver:
            self.driver.quit()
        
        proxy = self.proxy_list[self.current_proxy_index]
        
        chrome_options = Options()
        chrome_options.add_argument(f'--proxy-server={proxy}')
        chrome_options.add_argument('--headless')  # GUI के बिना
        
        self.driver = webdriver.Chrome(options=chrome_options)
        print(f"प्रॉक्सी के साथ ड्राइवर बनाया गया: {proxy}")
    
    def rotate(self):
        """अगले प्रॉक्सी पर स्विच करें"""
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        self.create_driver()
    
    def get_with_retry(self, url, max_retries=3):
        """त्रुटियों पर स्वचालित प्रॉक्सी परिवर्तन के साथ URL खोलें"""
        for attempt in range(max_retries):
            try:
                if not self.driver:
                    self.create_driver()
                
                self.driver.get(url)
                
                # ब्लॉक की जांच (उदाहरण के लिए, कैप्चा खोजना)
                if "captcha" in self.driver.page_source.lower():
                    print("कैप्चा मिला, प्रॉक्सी बदल रहे हैं...")
                    self.rotate()
                    time.sleep(3)
                    continue
                
                return self.driver.page_source
                
            except Exception as e:
                print(f"त्रुटि: {e}, प्रॉक्सी बदल रहे हैं (प्रयास {attempt+1})")
                self.rotate()
                time.sleep(3)
        
        raise Exception("पृष्ठ लोड नहीं हो सका")

# उपयोग:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
]

bot = SeleniumRotatingProxy(proxies)

# Ozon पार्स करें
for i in range(10):
    html = bot.get_with_retry(f"https://www.ozon.ru/category/page-{i}")
    print(f"पृष्ठ {i} का HTML प्राप्त किया, लंबाई: {len(html)}")

bot.driver.quit()

प्रॉक्सी रोटेशन के लिए middleware के साथ Scrapy

Scrapy — बड़े पैमाने पर पार्सिंग के लिए फ्रेमवर्क। प्रॉक्सी रोटेशन middleware के माध्यम से लागू किया जाता है, जो स्वचालित रूप से सभी अनुरोधों पर लागू होता है:

# middlewares.py

import random
from scrapy.exceptions import IgnoreRequest

class RotatingProxyMiddleware:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
    
    @classmethod
    def from_crawler(cls, crawler):
        # सेटिंग्स से प्रॉक्सी की सूची प्राप्त करें
        proxy_list = crawler.settings.getlist('ROTATING_PROXY_LIST')
        return cls(proxy_list)
    
    def process_request(self, request, spider):
        # प्रत्येक अनुरोध को यादृच्छिक प्रॉक्सी असाइन करें
        proxy = random.choice(self.proxy_list)
        request.meta['proxy'] = proxy
        spider.logger.info(f'प्रॉक्सी उपयोग कर रहे हैं: {proxy}')
    
    def process_exception(self, request, exception, spider):
        # प्रॉक्सी त्रुटि पर — दूसरे के साथ दोहराएं
        proxy = random.choice(self.proxy_list)
        spider.logger.warning(f'प्रॉक्सी त्रुटि, स्विच कर रहे हैं: {proxy}')
        request.meta['proxy'] = proxy
        return request  # अनुरोध दोहराएं

# settings.py

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.RotatingProxyMiddleware': 350,
}

ROTATING_PROXY_LIST = [
    'http://user:pass@gate1.com:8000',
    'http://user:pass@gate2.com:8000',
    'http://user:pass@gate3.com:8000',
]

# त्रुटियों पर अनुरोध दोहराएं
RETRY_TIMES = 5
RETRY_HTTP_CODES = [403, 429, 500, 502, 503]

अब प्रत्येक Scrapy अनुरोध स्वचालित रूप से सूची से यादृच्छिक प्रॉक्सी प्राप्त करेगा, और त्रुटियों पर दूसरे IP के साथ दोहराया जाएगा।

Node.js में स्वचालन: axios, Puppeteer, Playwright

Node.js असिंक्रोनसिटी और ब्राउज़र टूल के साथ अच्छे एकीकरण के कारण पार्सर और बॉट बनाने के लिए लोकप्रिय है। आइए मुख्य लाइब्रेरी में प्रॉक्सी रोटेशन के उदाहरण देखें।

स्वचालित रोटेशन के साथ Axios

Axios — HTTP-अनुरोधों के लिए लाइब्रेरी। प्रॉक्सी पूल और त्रुटियों पर स्वचालित प्रतिस्थापन के साथ एक क्लास बनाएंगे:

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class RotatingProxyClient {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
  }

  getProxy() {
    const proxy = this.proxyList[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
    return proxy;
  }

  async request(url, options = {}, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      const proxy = this.getProxy();
      const agent = new HttpsProxyAgent(proxy);

      try {
        const response = await axios.get(url, {
          ...options,
          httpsAgent: agent,
          timeout: 10000
        });

        // यदि ब्लॉक मिला — अगला प्रयास
        if ([403, 429, 503].includes(response.status)) {
          console.log(`स्थिति ${response.status}, प्रॉक्सी बदल रहे हैं...`);
          continue;
        }

        return response.data;

      } catch (error) {
        console.log(`प्रॉक्सी ${proxy} के साथ त्रुटि: ${error.message}`);
        if (i === maxRetries - 1) throw error;
      }
    }
  }
}

// उपयोग:
const proxies = [
  'http://user:pass@gate1.com:8000',
  'http://user:pass@gate2.com:8000',
];

const client = new RotatingProxyClient(proxies);

(async () => {
  for (let page = 1; page <= 20; page++) {
    const data = await client.request(`https://api.example.com/products?page=${page}`);
    console.log(`पृष्ठ ${page}: ${data.length} उत्पाद प्राप्त हुए`);
  }
})();

प्रॉक्सी रोटेशन के साथ Puppeteer

Puppeteer Chrome ब्राउज़र को नियंत्रित करता है। प्रॉक्सी ब्राउज़र लॉन्च करते समय सेट की जाती है, इसलिए बदलने के लिए इंस्टेंस को फिर से बनाना आवश्यक है:

const puppeteer = require('puppeteer');

class PuppeteerRotatingProxy {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
    this.browser = null;
  }

  async createBrowser() {
    if (this.browser) await this.browser.close();

    const proxy = this.proxyList[this.currentIndex];
    console.log(`प्रॉक्सी के साथ ब्राउज़र लॉन्च कर रहे हैं: ${proxy}`);

    this.browser = await puppeteer.launch({
      headless: true,
      args: [`--proxy-server=${proxy}`]
    });
  }

  rotate() {
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
  }

  async scrape(url, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      try {
        if (!this.browser) await this.createBrowser();

        const page = await this.browser.newPage();
        
        // प्रॉक्सी प्रमाणीकरण (यदि आवश्यक हो)
        await page.authenticate({
          username: 'your_username',
          password: 'your_password'
        });

        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

        // कैप्चा की जांच
        const content = await page.content();
        if (content.includes('captcha')) {
          console.log('कैप्चा मिला, प्रॉक्सी बदल रहे हैं...');
          this.rotate();
          await this.createBrowser();
          continue;
        }

        return content;

      } catch (error) {
        console.log(`त्रुटि: ${error.message}, प्रयास ${i+1}`);
        this.rotate();
        await this.createBrowser();
      }
    }
    throw new Error('पृष्ठ लोड नहीं हो सका');
  }
}

// उपयोग:
const proxies = ['gate1.com:8000', 'gate2.com:8000'];
const scraper = new PuppeteerRotatingProxy(proxies);

(async () => {
  const html = await scraper.scrape('https://www.avito.ru/moskva');
  console.log(`HTML प्राप्त किया, लंबाई: ${html.length}`);
  await scraper.browser.close();
})();

रोटेशन समर्थन के साथ Playwright

Playwright — बेहतर प्रदर्शन के साथ Puppeteer का आधुनिक विकल्प। प्रॉक्सी सेटअप समान है:

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

async function scrapeWithRotation(urls, proxyList) {
  let proxyIndex = 0;

  for (const url of urls) {
    const proxy = proxyList[proxyIndex];
    
    const browser = await chromium.launch({
      headless: true,
      proxy: {
        server: proxy,
        username: 'your_user',
        password: 'your_pass'
      }
    });

    const page = await browser.newPage();
    
    try {
      await page.goto(url, { timeout: 30000 });
      const title = await page.title();
      console.log(`${url} → ${title} (प्रॉक्सी: ${proxy})`);
    } catch (error) {
      console.log(`${url} पर त्रुटि: ${error.message}`);
    }

    await browser.close();
    
    // अगले URL के लिए अगला प्रॉक्सी
    proxyIndex = (proxyIndex + 1) % proxyList.length;
  }
}

const urls = [
  'https://www.wildberries.ru',
  'https://www.ozon.ru',
  'https://www.avito.ru'
];

const proxies = [
  'http://gate1.com:8000',
  'http://gate2.com:8000'
];

scrapeWithRotation(urls, proxies);

एंटी-डिटेक्ट ब्राउज़र के साथ API एकीकरण: Dolphin Anty, AdsPower

मल्टी-अकाउंटिंग के साथ काम करने वाले आर्बिट्राजर्स और SMM विशेषज्ञों के लिए, Dolphin Anty या AdsPower में प्रत्येक प्रोफ़ाइल को मैन्युअल रूप से प्रॉक्सी असाइन करना घंटों लगता है। इन ब्राउज़रों का API प्रोफ़ाइल बनाने और प्रॉक्सी बाइंडिंग को स्वचालित करने की अनुमति देता है।

API के माध्यम से Dolphin Anty का स्वचालन

Dolphin Anty एक स्थानीय API प्रदान करता है (आमतौर पर http://localhost:3001/v1.0 पर), जिसके माध्यम से प्रोफ़ाइल बनाई जा सकती हैं, प्रॉक्सी असाइन की जा सकती हैं, ब्राउज़र प्रोग्रामेटिक रूप से लॉन्च किए जा सकते हैं।

अद्वितीय प्रॉक्सी के साथ प्रोफ़ाइल के बड़े पैमाने पर निर्माण के लिए Python स्क्रिप्ट का उदाहरण:

import requests
import json

DOLPHIN_API = "http://localhost:3001/v1.0"
API_TOKEN = "your_dolphin_api_token"

# आपके प्रदाता से प्रॉक्सी की सूची (उनके API के माध्यम से प्राप्त)
proxies = [
    {"host": "gate1.com", "port": 8000, "login": "user1", "password": "pass1"},
    {"host": "gate2.com", "port": 8000, "login": "user2", "password": "pass2"},
]

def create_profile_with_proxy(name, proxy):
    """प्रॉक्सी बाइंडिंग के साथ Dolphin में प्रोफ़ाइल बनाएं"""
    
    payload = {
        "name": name,
        "tags": ["Facebook Ads", "Auto-created"],
        "proxy": {
            "type": "http",  # या socks5
            "host": proxy["host"],
            "port": proxy["port"],
            "login": proxy["login"],
            "password": proxy["password"]
        },
        "fingerprint": {
            "os": "win",
            "webRTC": {
                "mode": "altered",
                "fillBasedOnIp": True
            },
            "canvas": {
                "mode": "noise"
            }
        }
    }
    
    headers = {
        "Authorization": f"Bearer {API_TOKEN}",
        "Content-Type": "application/json"
    }
    
    response = requests.post(
        f"{DOLPHIN_API}/browser_profiles",
        headers=headers,
        data=json.dumps(payload)
    )
    
    if response.status_code == 200:
        profile = response.json()
        print(f"✓ प्रोफ़ाइल बनाई गई: {name}, ID: {profile['id']}")
        return profile['id']
    else:
        print(f"✗ {name} बनाने में त्रुटि: {response.text}")
        return None

# प्रॉक्सी रोटेशन के साथ 50 प्रोफ़ाइल बनाएं
for i in range(50):
    proxy = proxies[i % len(proxies)]  # चक्रीय रोटेशन
    profile_name = f"FB_Account_{i+1:03d}"
    create_profile_with_proxy(profile_name, proxy)

अब आपके पास Dolphin Anty में 50 प्रोफ़ाइल हैं, प्रत्येक अद्वितीय ब्राउज़र फ़िंगरप्रिंट और प्रॉक्सी के साथ। प्रोफ़ाइल को प्रोग्रामेटिक रूप से लॉन्च करने के लिए:

def start_profile(profile_id):
    """ब्राउज़र प्रोफ़ाइल लॉन्च करें"""
    response = requests.get(
        f"{DOLPHIN_API}/browser_profiles/{profile_id}/start",
        headers={"Authorization": f"Bearer {API_TOKEN}"}
    )
    
    if response.status_code == 200:
        data = response.json()
        print(f"प्रोफ़ाइल लॉन्च की गई, WebDriver पोर्ट: {data['automation']['port']}")
        return data['automation']['port']
    else:
        print(f"लॉन्च त्रुटि: {response.text}")

# प्रोफ़ाइल लॉन्च करें और Selenium के माध्यम से नियंत्रित करें
port = start_profile("profile_id_here")

from selenium import webdriver
driver = webdriver.Remote(
    command_executor=f'http://127.0.0.1:{port}',
    options=webdriver.ChromeOptions()
)
driver.get("https://facebook.com")

AdsPower का स्वचालन

AdsPower भी एक स्थानीय API प्रदान करता है। तर्क Dolphin के समान है, लेकिन विभिन्न एंडपॉइंट के साथ:

import requests

ADSPOWER_API = "http://local.adspower.net:50325/api/v1"

def create_adspower_profile(name, proxy):
    payload = {
        "name": name,
        "group_id": "0",  # प्रोफ़ाइल समूह ID
        "domain_name": "facebook.com",
        "open_urls": ["https://facebook.com"],
        "repeat_config": ["0"],
        "username": proxy["login"],
        "password": proxy["password"],
        "proxy_type": "http",
        "proxy_host": proxy["host"],
        "proxy_port": proxy["port"],
        "proxy_user": proxy["login"],
        "proxy_password": proxy["password"]
    }
    
    response = requests.post(
        f"{ADSPOWER_API}/user/create",
        json=payload
    )
    
    if response.json()["code"] == 0:
        user_id = response.json()["data"]["id"]
        print(f"✓ AdsPower प्रोफ़ाइल बनाई गई: {name}, ID: {user_id}")
        return user_id
    else:
        print(f"✗ त्रुटि: {response.json()['msg']}")

# प्रोफ़ाइल बनाना
for i, proxy in enumerate(proxies):
    create_adspower_profile(f"TikTok_Account_{i+1}", proxy)

दर्जनों अकाउंट के साथ काम करते समय ऐसा स्वचालन महत्वपूर्ण है। प्रत्येक प्रोफ़ाइल में प्रॉक्सी डेटा को मैन्युअल रूप से कॉपी करने के बजाय, आप स्क्रिप्ट चलाते हैं और मिनटों में तैयार इंफ्रास्ट्रक्चर प्राप्त करते हैं।

त्रुटि प्रबंधन और स्वचालित फॉलबैक

प्रॉक्सी के साथ काम करते समय स्थितियां अपरिहार्य हैं: IP लक्षित साइट द्वारा ब्लॉक किया गया, प्रॉक्सी सर्वर प्रतिक्रिया नहीं दे रहा, ट्रैफ़िक समाप्त हो गया। सही त्रुटि प्रबंधन — स्थिर स्वचालन की कुंजी।

त्रुटियों के प्रकार और प्रबंधन रणनीतियां

त्रुटि	कारण	समाधान
HTTP 403 Forbidden	साइट की बैन-सूची में IP	प्रॉक्सी बदलें, देरी जोड़ें
HTTP 429 Too Many Requests	Rate limit पार हो गई	IP बदलें, अंतराल बढ़ाएं
ProxyError / Timeout	प्रॉक्सी सर्वर प्रतिक्रिया नहीं दे रहा	पूल से हटाएं, अगला लें
407 Proxy Authentication Required	गलत लॉगिन/पासवर्ड	Credentials जांचें, अपडेट करें
पृष्ठ पर कैप्चा	साइट ने बॉट का पता लगाया	IP बदलें, मोबाइल प्रॉक्सी उपयोग करें

स्मार्ट retry सिस्टम का कार्यान्वयन

सरल अनुरोध पुनरावृत्ति के बजाय, एक्सपोनेंशियल देरी और काम न करने वाले प्रॉक्सी की ब्लैकलिस्ट के साथ एक सिस्टम बनाएंगे:

import requests
import time
from collections import defaultdict

class SmartProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.blacklist = set()  # IP जो काम नहीं कर रहे
        self.error_count = defaultdict(int)  # IP द्वारा त्रुटि काउंटर
        self.max_errors = 3  # 3 त्रुटियों के बाद — ब्लैकलिस्ट में
    
    def get_working_proxy(self):
        """प्रॉक्सी प्राप्त करें जो ब्लैकलिस्ट में नहीं है"""
        available = [p for p in self.proxy_list if p not in self.blacklist]
        if not available:
            # सभी प्रॉक्सी बैन में — ब्लैकलिस्ट साफ़ करें
            print("⚠ सभी प्रॉक्सी ब्लॉक हैं, ब्लैकलिस्ट रीसेट कर रहे हैं")
            self.blacklist.clear()
            self.error_count.clear()
            available = self.proxy_list
        return available[0]
    
    def mark_error(self, proxy):
        """प्रॉक्सी त्रुटि चिह्नित करें"""
        self.error_count[proxy] += 1
        if self.error_count[proxy] >= self.max_errors:
            self.blacklist.add(proxy)
            print(f"✗ प्रॉक्सी {proxy} ब्लैकलिस्ट में जोड़ा गया")
    
    def request_with_retry(self, url, max_retries=5):
        """स्मार्ट पुनरावृत्तियों के साथ अनुरोध"""
        for attempt in range(max_retries):
            proxy = self.get_working_proxy()
            
            try:
                # एक्सपोनेंशियल देरी: 1s, 2s, 4s, 8s...
                if attempt > 0:
                    delay = 2 ** attempt
                    print(f"प्रयास {attempt+1} से पहले {delay}s प्रतीक्षा")
                    time.sleep(delay)
                
                response = requests.get(
                    url,
                    proxies={"http": proxy, "https": proxy},
                    timeout=15
                )
                
                # सफलता — त्रुटि काउंटर रीसेट करें
                if response.status_code == 200:
                    self.error_count[proxy] = 0
                    return response
                
                # ब्लॉक — प्रॉक्सी बदलें
                elif response.status_code in [403, 429]:
                    print(f"स्थिति {response.status_code}, प्रॉक्सी बदल रहे हैं")
                    self.mark_error(proxy)
                    continue
                
            except requests.exceptions.ProxyError:
                print(f"{proxy} के साथ ProxyError")
                self.mark_error(proxy)
                
            except requests.exceptions.Timeout:
                print(f"{proxy} के साथ Timeout")
                self.mark_error(proxy)
        
        raise Exception(f"{max_retries} प्रयासों के बाद अनुरोध निष्पादित नहीं हो सका")

# उपयोग:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
    "http://user:pass@gate3.com:8000",
]

rotator = SmartProxyRotator(proxies)

for i in range(100):
    try:
        response = rotator.request_with_retry(f"https://api.example.com/data?page={i}")
        print(f"✓ पृष्ठ {i}: {len(response.text)} बाइट्स")
    except Exception as e:
        print(f"✗ पृष्ठ {i} पर गंभीर त्रुटि: {e}")

मॉनिटरिंग और अलर्ट

प्रोडक्शन सिस्टम के लिए रीयल-टाइम में प्रॉक्सी पूल के स्वास्थ्य को ट्रैक करना महत्वपूर्ण है। मेट्रिक्स लॉगिंग जोड़ें:

import logging
from datetime import datetime

class ProxyMonitor:
    def __init__(self):
        self.stats = {
            "total_requests": 0,
            "successful": 0,
            "failed": 0,
            "proxy_errors": defaultdict(int),
            "start_time": datetime.now()
        }
        
        # लॉगिंग सेटअप
        logging.basicConfig(
            filename='proxy_rotation.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
    
    def log_request(self, proxy, success, error=None):
        self.stats["total_requests"] += 1
        
        if success:
            self.stats["successful"] += 1
            logging.info(f"✓ {proxy} के साथ सफलता")
        else:
            self.stats["failed"] += 1
            self.stats["proxy_errors"][proxy] += 1
            logging.error(f"✗ {proxy} के साथ त्रुटि: {error}")
    
    def get_report(self):
        uptime = datetime.now() - self.stats["start_time"]
        success_rate = (self.stats["successful"] / self.stats["total_requests"] * 100) if self.stats["total_requests"] > 0 else 0
        
        return f"""
=== प्रॉक्सी-रोटेशन रिपोर्ट ===
अपटाइम: {uptime}
कुल अनुरोध: {self.stats["total_requests"]}
सफल: {self.stats["successful"]} ({success_rate:.1f}%)
त्रुटियां: {self.stats["failed"]}

समस्याग्रस्त प्रॉक्सी:
{self._format_errors()}
        """
    
    def _format_errors(self):
        sorted_errors = sorted(
            self.stats["proxy_errors"].items(),
            key=lambda x: x[1],
            reverse=True
        )
        return "\n".join([f"  {proxy}: {count} त्रुटियां" for proxy, count in sorted_errors[:5]])

# rotator के साथ एकीकरण
monitor = ProxyMonitor()

# अनुरोध लूप में:
try:
    response = rotator.request_with_retry(url)
    monitor.log_request(current_proxy, success=True)
except Exception as e:
    monitor.log_request(current_proxy, success=False, error=str(e))

सर्वोत्तम प्रथाएं और ट्रैफ़िक खपत का अनुकूलन

प्रॉक्सी रोटेशन के साथ काम करते समय कुछ सिद्ध प्रथाएं हैं जो लागत कम करने और दक्षता बढ़ाने में मदद करती हैं:

अनुरोधों के बीच देरी: तुरंत 100 अनुरोध न भेजें — 1-3 सेकंड का अंतराल जोड़ें। यह अधिक मानवीय दिखता है और ब्लॉक की संभावना कम करता है
User-Agent रोटेशन: IP के साथ ब्राउज़र हेडर भी बदलें। एक ही User-Agent के साथ विभिन्न IP से अनुरोध संदिग्ध हैं
कुकीज़ प्रबंधन: प्रत्येक प्रॉक्सी के लिए अलग कुकी सत्र बनाए रखें। साझा कुकीज़ विभिन्न IP को एक उपयोगकर्ता से जोड़ सकती हैं
भू-लक्ष्यीकरण: यदि आप किसी विशिष्ट देश के लिए डेटा पार्स कर रहे हैं — उसी क्षेत्र से प्रॉक्सी उपयोग करें। यह अधिक विश्वसनीय है और तेज़ है
सत्र पुन: उपयोग: जहां संभव हो sticky sessions उपयोग करें। प्रत्येक अनुरोध पर IP बदलना अधिक ट्रैफ़िक खर्च करता है

ट्रैफ़िक अनुकूलन का उदाहरण:

# खराब: प्रत्येक अनुरोध पर नया IP
for url in urls:
    response = requests.get(url, proxies=get_new_proxy())

# अच्छा: 10 अनुरोधों के लिए एक सत्र
session_proxy = get_sticky_session(duration=600)  # 10 मिनट
for i, url in enumerate(urls):
    if i % 10 == 0:  # हर 10 अनुरोध पर बदलें
        session_proxy = get_sticky_session(duration=600)
    response = requests.get(url, proxies=session_proxy)

निष्कर्ष

API के माध्यम से प्रॉक्सी रोटेशन का स्वचालन आधुनिक पार्सिंग, आर्बिट्राज और मल्टी-अकाउंटिंग का आधार है। सही कार्यान्वयन के साथ, आप:

डेटा संग्रह की गति 10-100 गुना बढ़ाएं
ब्लॉक और कैप्चा की संख्या 90% तक कम करें
दर्जनों और सैकड़ों अकाउंट के प्रबंधन को स्वचालित करें
स्मार्ट रोटेशन के माध्यम से ट्रैफ़िक लागत कम करें

मुख्य बात — अपने कार्य के लिए सही रोटेशन रणनीति चुनना है: sticky sessions मल्टी-अकाउंटिंग के लिए, ऑटो-रोटेशन आक्रामक पार्सिंग के लिए, हाइब्रिड दृष्टिकोण सार्वभौमिक समाधानों के लिए। इस गाइड में दिए गए कोड उदाहरण किसी भी परियोजना के लिए आधार के रूप में काम कर सकते हैं।

विश्वसनीय प्रॉक्सी की आवश्यकता है जो API के साथ काम करती हैं? ProxyCove 195+ देशों से रेजिडेंशियल और मोबाइल प्रॉक्सी प्रदान करता है, sticky sessions के समर्थन, विस्तृत API दस्तावेज़ीकरण और 24/7 तकनीकी सहायता के साथ।

```

एपीआई के माध्यम से प्रॉक्सी स्विचिंग का स्वचालन: पार्सिंग और आर्बिट्राज के लिए रोटेशन सेटअप कैसे करें

API के माध्यम से प्रॉक्सी रोटेशन के स्वचालन की आवश्यकता क्यों है

प्रॉक्सी रोटेशन के प्रकार: sticky sessions बनाम स्वचालित परिवर्तन

Sticky Sessions (सत्र प्रॉक्सी)

प्रत्येक अनुरोध पर स्वचालित रोटेशन

टाइमर द्वारा रोटेशन

प्रॉक्सी सेवाओं के API के साथ काम करने की मूल बातें

प्रॉक्सी सेवाओं के विशिष्ट API-मेथड

API के माध्यम से सत्र प्रबंधन

Python में स्वचालन के उदाहरण: requests, Selenium, Scrapy

requests में स्वचालित प्रॉक्सी परिवर्तन

ब्राउज़र स्वचालन के लिए Selenium के साथ एकीकरण

प्रॉक्सी रोटेशन के लिए middleware के साथ Scrapy

Node.js में स्वचालन: axios, Puppeteer, Playwright

स्वचालित रोटेशन के साथ Axios

प्रॉक्सी रोटेशन के साथ Puppeteer

रोटेशन समर्थन के साथ Playwright

एंटी-डिटेक्ट ब्राउज़र के साथ API एकीकरण: Dolphin Anty, AdsPower

API के माध्यम से Dolphin Anty का स्वचालन

AdsPower का स्वचालन

त्रुटि प्रबंधन और स्वचालित फॉलबैक

त्रुटियों के प्रकार और प्रबंधन रणनीतियां

स्मार्ट retry सिस्टम का कार्यान्वयन

मॉनिटरिंग और अलर्ट

सर्वोत्तम प्रथाएं और ट्रैफ़िक खपत का अनुकूलन

निष्कर्ष