प्रॉक्सी के साथ वेब स्क्रैपिंग: एक ज़िम्मेदार गाइड

प्रॉक्सी प्रति-IP सीमाएँ हल करते हैं, ख़राब स्क्रैपर डिज़ाइन नहीं। दोनों को ज़िम्मेदारी से कैसे मिलाएँ, यहाँ पढ़ें।

14 मिनट में पढ़ें

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

शिष्टाचार से शुरुआत करें

  • पहले आधिकारिक API या डेटा एक्सपोर्ट देखें।
  • robots.txt और साइट की शर्तें पढ़ें।
  • जहाँ ज़रूरी हो वहाँ अपने स्क्रैपर की पहचान ईमानदारी से बताएँ और रिक्वेस्ट दर संयमित रखें।
  • कानूनी आधार के बिना व्यक्तिगत डेटा एकत्र करने से बचें।

सही IP प्रकार चुनें

सहनशील साइटों के लिए डेटासेंटर IP सबसे सस्ते हैं। जो साइटें होस्टिंग रेंज फ़िल्टर करती हैं, वहाँ रेज़िडेंशियल रोटेटिंग IP मदद करते हैं। ऑथेंटिकेटेड फ़्लो के लिए स्टैटिक ISP IP उपयुक्त हैं। विवरण के लिए रेज़िडेंशियल बनाम डेटासेंटर गाइड देखें।

विफलता को ध्यान में रखकर डिज़ाइन करें

429 (बहुत ज़्यादा रिक्वेस्ट), 403 और टाइमआउट की अपेक्षा रखें। एक्सपोनेंशियल बैकऑफ़ के साथ रिट्राई करें, बार-बार ब्लॉक होने पर दूसरे IP पर जाएँ और हर IP के लिए स्टेटस कोड लॉग करें ताकि पैटर्न दिख सकें।

Python
import random, time, requests

PROXIES = ["http://USER:PASS@HOST1:PORT", "http://USER:PASS@HOST2:PORT"]

def fetch(url, tries=4):
    for i in range(tries):
        proxy = random.choice(PROXIES)
        try:
            r = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=15)
            if r.status_code == 200:
                return r.text
            if r.status_code in (403, 429):
                time.sleep(2 ** i + random.random())
        except requests.RequestException:
            time.sleep(1 + random.random())
    return None

बैंडविड्थ नियंत्रित करें

GB-मीटर्ड प्लान पर, इमेज, फ़ॉन्ट और मीडिया ब्लॉक करें और जहाँ संभव हो JSON एंडपॉइंट फ़ेच करें। अपने मासिक उपयोग का अनुमान लगाने के लिए एक सैंपल मापें।

क्रॉलर लिखने से पहले नियम पढ़ें

robots.txt से शुरू करें, लेकिन जानें कि वह क्या है। Robots Exclusion Protocol (RFC 9309) हर origin की रूट पर परोसी जाने वाली एक फ़ाइल है जो क्रॉलरों को बताती है कि उन्हें किन पाथ पर रिक्वेस्ट नहीं भेजनी चाहिए; यह user-agent के अनुसार समूहबद्ध होती है और सबसे विशिष्ट मेल खाता नियम लागू होता है। अगर फ़ाइल 4xx स्टेटस लौटाए, तो क्रॉलर साइट को बिना किसी प्रतिबंध वाली मान सकते हैं; अगर वह 5xx लौटाए या पहुँच से बाहर हो, तो मानक कहता है कि फिर से चालू होने तक सब कुछ वर्जित मान लिया जाए। Crawl-delay मानक का हिस्सा नहीं है और हर क्रॉलर उसे नहीं मानता, लेकिन अगर कोई साइट उसे प्रकाशित करती है, तो उसे धीमा करने का अनुरोध समझें।

robots.txt क्रॉलरों के लिए एक परंपरा है, लाइसेंस नहीं। फ़ाइल में कुछ भी लिखा हो, सेवा की शर्तें स्वचालित पहुँच पर रोक लगा सकती हैं, और डेटा के साथ आप जो करते हैं उस पर दूसरे नियम भी लागू हो सकते हैं: सामग्री का कॉपीराइट, कुछ क्षेत्राधिकारों में डेटाबेस अधिकार, और अगर डेटा लोगों की पहचान कराता है तो EU में GDPR या तुर्की में KVKK जैसा डेटा-संरक्षण क़ानून। यह सामान्य जानकारी है, क़ानूनी सलाह नहीं; अगर प्रोजेक्ट व्यावसायिक है, तो किसी योग्य व्यक्ति से उसकी समीक्षा करवाएँ। ऑथेंटिकेशन, पेवॉल या एक्सेस कंट्रोल को कभी बायपास न करें, और CAPTCHA या access-denied पेज को धीमा पड़ने या रुकने का संकेत मानें, ऐसी बाधा नहीं जिसे टूलिंग से हराना हो।

प्रॉक्सी टूलHTTP हेडर चेकरकिसी सार्वजनिक URL को रिक्वेस्ट करें और उसके रिस्पॉन्स हेडर, रीडायरेक्ट चेन और यह देखें कि आम सुरक्षा हेडर मौजूद हैं या नहीं।देखें

रोटेशन से पहले रेट लिमिटर बनाएँ

पतों का बड़ा पूल आपको बड़े लोड का हक़ नहीं देता। हर रिक्वेस्ट का बोझ सर्वर को ही उठाना पड़ता है, और सीमाएँ प्रति अकाउंट, प्रति सेशन कुकी, प्रति नेटवर्क ब्लॉक या प्रति फ़िंगरप्रिंट लागू हो सकती हैं, सिर्फ़ प्रति IP नहीं। बजट प्रति टार्गेट होस्ट तय करें, प्रति प्रॉक्सी नहीं: इन-फ़्लाइट रिक्वेस्ट पर एक सीमा (दो से पाँच एक समझदार शुरुआत है, उदाहरण के तौर पर), रिक्वेस्ट के बीच रैंडम जिटर वाली न्यूनतम देरी, और एक अनुकूली नियम जो 429 या 503 पर दर आधी कर दे और सफलताओं की एक कड़ी के बाद उसे छोटे क़दमों में फिर बढ़ाए, काफ़ी हद तक TCP के कंजेशन कंट्रोल की तरह।

शिष्टाचार की एक समय-क़ीमत है जिसकी आपको योजना बनानी चाहिए और जिसे IP की कोई भी संख्या हटा नहीं सकती। 2 रिक्वेस्ट प्रति सेकंड पर 100,000 पेज फ़ेच करने में 50,000 सेकंड, यानी लगभग 13.9 घंटे लगते हैं; 5 रिक्वेस्ट प्रति सेकंड पर 20,000 सेकंड, यानी लगभग 5.6 घंटे लगते हैं। अगर यह बहुत धीमा है, तो जवाब है छोटा दायरा, इन्क्रीमेंटल अपडेट या साइट के साथ समझौता, ज़्यादा पते नहीं।

ऐसे रीट्राई जो मदद करें, नुक़सान नहीं

जिटर वाला बैकऑफ़ कई वर्करों को एक साथ, एक ही लय में रीट्राई करने से रोकता है। “फ़ुल जिटर” शून्य और min(cap, base × 2^attempt) के बीच कोई रैंडम समय सोता है, जिससे रीट्राई पूरी खिड़की में फैल जाते हैं। अगर 429 या 503 रिस्पॉन्स में Retry-After हेडर हो, जिसमें सेकंड की संख्या या HTTP तारीख़ होती है, तो कम से कम उतनी देर इंतज़ार करें। कनेक्ट और रीड के अलग टाइमआउट इस्तेमाल करें, प्रति URL प्रयास और कुल समय, दोनों पर सीमा लगाएँ, और लूप लिखने से पहले तय करें कि हर स्टेटस का क्या मतलब है:

  • बैकऑफ़ के साथ रीट्राई: टाइमआउट, कनेक्शन रीसेट, 429, 502, 503 और 504। ये आमतौर पर अस्थायी होते हैं या धीमा होने का अनुरोध।
  • नए कनेक्शन या सेशन पर एक बार रीट्राई: ऐसी विफलताएँ जो किसी एक एग्ज़िट नोड से जुड़ी लगें, जैसे बार-बार आने वाली प्रॉक्सी-साइड कनेक्शन एरर।
  • रीट्राई न करें: 404 और 410 का मतलब है कि पेज जा चुका है, इसलिए उन्हें दर्ज करें। 401 और 403 पहुँच के फ़ैसले हैं, गड़बड़ियाँ नहीं, और कई पतों से उन्हें दोहराना पूरी रेंज को ब्लॉक करवाने का तेज़ तरीक़ा है।
  • 407 को अपनी ही कॉन्फ़िगरेशन की समस्या मानें: यह प्रॉक्सी क्रेडेंशियल्स माँग रही है, वेबसाइट आपको मना नहीं कर रही।

नीचे का फ़ंक्शन इन टुकड़ों को जोड़ता है: ऊपर के स्टेटस नियमों का पालन करने वाली robots.txt जाँच, फ़ुल-जिटर बैकऑफ़, Retry-After का संचालन और एक स्टेटस नीति। यह ढालने के लिए टेम्पलेट है, तैयार क्रॉलर नहीं।

Python
import random
import time
import urllib.robotparser

import requests

UA = "ExampleBot/1.0 (+https://example.com/bot-info)"
PROXY = "http://USER:PASS@HOST:PORT"
PROXIES = {"http": PROXY, "https": PROXY}
HEADERS = {"User-Agent": UA}

robots = urllib.robotparser.RobotFileParser()
resp = requests.get("https://example.org/robots.txt", headers=HEADERS, proxies=PROXIES, timeout=15)
if resp.status_code == 200:
    robots.parse(resp.text.splitlines())
elif resp.status_code >= 500:
    robots.disallow_all = True
else:
    robots.allow_all = True

def backoff(attempt, base=1.0, cap=60.0):
    return random.uniform(0, min(cap, base * 2 ** attempt))

def polite_get(url, tries=5):
    if not robots.can_fetch(UA, url):
        return None
    for attempt in range(tries):
        try:
            r = requests.get(url, headers=HEADERS, proxies=PROXIES, timeout=(5, 20))
        except requests.RequestException:
            time.sleep(backoff(attempt))
            continue
        if r.status_code == 200:
            return r.text
        if r.status_code in (429, 503):
            wait = r.headers.get("Retry-After", "")
            time.sleep(min(float(wait), 300) if wait.isdigit() else backoff(attempt))
        elif r.status_code in (500, 502, 504):
            time.sleep(backoff(attempt))
        else:
            return None
    return None

हर प्रॉक्सी को हेल्थ स्कोर वाला कॉम्पोनेंट मानें

लंबे रन में अलग-अलग एग्ज़िट ख़राब हो जाते हैं: कोई नोड रेट-लिमिट हो जाता है, कोई गेटवे रीस्टार्ट होता है, कोई क्रेडेंशियल एक्सपायर हो जाता है। प्रति प्रॉक्सी या प्रति सेशन काउंटर रखें (सफलताएँ, 429, 403, टाइमआउट, बाइट) और प्रॉक्सी की गड़बड़ी को टार्गेट की गड़बड़ी से अलग करें। कनेक्शन refused, प्रॉक्सी टाइमआउट, 407 और गेटवे द्वारा बनाए गए 502 प्रॉक्सी की ओर इशारा करते हैं; साइट से आए 403 और 429 टार्गेट और आपके व्यवहार की ओर। प्रॉक्सी चेकर के एरर कोड (auth, refused, timeout, not_http_proxy, tls और अन्य) इसी बँटवारे का पालन करते हैं, इसलिए आप संदिग्ध प्रॉक्सी को अपने क्रॉलर से स्वतंत्र रूप से जाँच सकते हैं।

एक सर्किट ब्रेकर जोड़ें। लगातार विफलताओं की तय संख्या के बाद, जैसे पाँच (केवल उदाहरण के लिए), उस प्रॉक्सी को ठंडा होने की अवधि, जैसे दस मिनट, के लिए रोटेशन से बाहर कर दें, फिर बहाल करने से पहले एक रिक्वेस्ट से उसे परखें। पहली ही एरर पर प्रॉक्सी को हमेशा के लिए हटा देने से चुकाई हुई क्षमता बर्बाद होती है, जबकि विफल होती प्रॉक्सी पर लगातार चोट करने से मीटर्ड प्लान पर बैंडविड्थ जलती है।

क्रॉल को दोबारा शुरू करने योग्य और सस्ता बनाएँ

  • हर URL की स्थिति, प्रयासों की गिनती और आख़िरी एरर के साथ एक कतार सहेजें, ताकि क्रैश या डिप्लॉयमेंट के बाद काम दोबारा फ़ेच करने के बजाय वहीं से आगे चले।
  • कतार में डालने से पहले URL को सामान्य (नॉर्मलाइज़) करें और डुप्लीकेट हटाएँ (ट्रैकिंग पैरामीटर, क्वेरी-स्ट्रिंग का क्रम, अंत के स्लैश)।
  • कंडीशनल रिक्वेस्ट इस्तेमाल करें: ETag या Last-Modified मान सहेजें और अगली बार If-None-Match या If-Modified-Since भेजें। 304 रिस्पॉन्स में बॉडी नहीं होती, जिससे GB-मीटर्ड प्लान पर डेटा और साइट पर लोड बचता है।
  • कम्प्रेशन स्वीकार करें; ज़्यादातर HTTP क्लाइंट gzip अपने-आप संभाल लेते हैं, और वह आमतौर पर HTML और JSON को काफ़ी छोटा कर देता है।
  • पार्स करने से पहले कच्चे रिस्पॉन्स सहेजें, ताकि पार्सर की गड़बड़ी का मतलब फ़ाइलों को दोबारा प्रोसेस करना हो, रिक्वेस्ट फिर से ख़र्च करना नहीं।
  • सिर्फ़ स्टेटस नहीं, सामग्री भी जाँचें: जिस 200 में ब्लॉक पेज या लॉगिन फ़ॉर्म हो वह विफलता है, इसलिए किसी पेज को सफल गिनने से पहले अपेक्षित एलिमेंट की मौजूदगी ज़रूरी रखें।

हर सेशन को भीतर से एकरूप रखें

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

प्रोडक्शन में क्या मॉनिटर करें

  • प्रति टार्गेट और प्रति प्रॉक्सी या सेशन सफलता दर, सामग्री-सत्यापन लागू करके।
  • लेटेंसी परसेंटाइल (मध्यिका और 95वाँ), क्योंकि औसत उस धीमी पूँछ को छिपा देते हैं जो वर्करों को अटका देती है।
  • प्रति सफल रिकॉर्ड बाइट और प्रति 1,000 रिकॉर्ड लागत, जो प्रॉक्सी बिलिंग को ऐसी इकाई-लागत में बदल देती है जिसकी तुलना आप IP प्रकारों के बीच कर सकें।
  • समय के साथ 429 और 403 रिस्पॉन्स का हिस्सा; बढ़ता रुझान बताता है कि ब्लॉक आने से पहले आपकी दर या पैटर्न पर ध्यान चाहिए।
  • डेटा की ताज़गी: हर पेज आख़िरी बार कब सफलतापूर्वक फ़ेच हुआ, इसकी तुलना इससे कि उसे कितनी बार रीफ़्रेश करना ज़रूरी है।

अक्सर पूछे जाने वाले प्रश्न

नए IP पर भी मुझे 403 रिस्पॉन्स क्यों मिलते हैं?

पता केवल एक संकेत है। साइटें हेडर, आपके HTTP क्लाइंट की विशेषताएँ, कुकी, रिक्वेस्ट की दर और पैटर्न, और यह भी देखती हैं कि सामग्री के लिए अकाउंट चाहिए या नहीं। कई अलग-अलग IP पर दोहराने वाला 403 आमतौर पर बताता है कि कारण पता नहीं है, इसलिए और रोटेट करने से मदद नहीं मिलेगी। धीमे हों, साइट की शर्तें दोबारा पढ़ें और देखें कि कोई आधिकारिक API है या नहीं।

कौन-सी रिक्वेस्ट दर सुरक्षित है?

कोई सार्वभौमिक संख्या नहीं है। कम से शुरू करें, उदाहरण के तौर पर प्रति होस्ट प्रति सेकंड एक रिक्वेस्ट, 429 रिस्पॉन्स के हिस्से और लेटेंसी के रुझान पर नज़र रखें, और दर को छोटे क़दमों में बढ़ाएँ। अगर साइट रेट लिमिट, API कोटा या robots.txt में Crawl-delay प्रकाशित करती है, तो वही आपकी ऊपरी सीमा तय करता है।

क्या मैं लॉगिन के पीछे रखे डेटा को स्क्रैप कर सकता हूँ?

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

तय नहीं कर पा रहे कि कौन-सा प्लान सही है?

अपना उपयोग और लक्षित देश बताएँ, हम कोई प्रोडक्ट सुझाएँगे — या ईमानदारी से बताएँगे कि आपके लिए कोई दूसरा प्रकार बेहतर है।