वेब स्क्रैपिंग और एजेंट्स

AI क्रॉलर्स और एजेंट्स में HTTP 429 और Cloudflare 520 एरर कैसे ठीक करें

2026-09-02·21 मिनट पढ़ने का समय मिनट पठन·LLMPodium Team

त्वरित उत्तर: HTTP 429 एरर टारगेट API या WAF की रेट लिमिट (अनुरोध सीमा) पार होने का संकेत देता है, जिसे डीकोरिलेटेड जिटर (Decorrelated Jitter) बैकऑफ़ और रोटेटिंग रेजिडेंशियल प्रॉक्सी से ठीक किया जाता है। Cloudflare 520 एरर ("Web Server Returned an Unknown Error") तब आता है जब क्रॉलर के भारी लोड के कारण ओरिजिन सर्वर क्रैश हो जाता है या अधूरा TCP RST रिस्पांस भेजता है।

1. परिचय: ऑटोनॉमस AI क्रॉलर्स की चुनौतियाँ

जैसे-जैसे ऑटोनॉमस AI एजेंट्स चैटबॉट से आगे बढ़कर मल्टी-स्टेप रीज़निंग इंजनों में बदल रहे हैं (रियल-टाइम वेब रिसर्च, वित्तीय विश्लेषण, कोड सर्च), सबसे बड़ी बाधा LLM की स्पीड नहीं बल्कि नेटवर्क विश्वसनीयता और एज (Edge) एक्सेस बन गई है।

आधुनिक AI एजेंट्स प्रति मिनट हज़ारों HTTP कॉल्स करते हैं। पुराने स्क्रैपर्स की तुलना में AI एजेंट्स को आवश्यकता होती है:

  1. अति-निम्न लेटेंसी और सिंक्रोनस वेब डेटा ताकि रीज़निंग लूप न रुके।
  2. सटीक जावास्क्रिप्ट निष्पादन ताकि SPA साइट्स को लोड किया जा सके।
  3. क्लीन मार्कडाउन रूपांतरण ताकि संदर्भ टोकन व्यर्थ न हों।

लेकिन Cloudflare और DataDome जैसे सुरक्षा सिस्टम्स संदिग्ध ट्रैफिक को ब्लॉक करने के लिए दो प्रमुख एरर कोड्स का उपयोग करते हैं:

  • HTTP 429 Too Many Requests: तय सीमा से अधिक अनुरोध भेजना।
  • HTTP 520 Web Server Returned an Unknown Error: ओरिजिन सर्वर का Cloudflare एज के साथ कनेक्शन टूटना।

2. HTTP 429 एरर का विश्लेषण

HTTP 429 तीन प्रमुख लेयर्स पर उत्पन्न होता है:

  1. लेयर 1: एज WAF (Cloudflare / DataDome): Python ओपन-एसएसएल फ़िंगरप्रिंट (JA4) और ब्राउज़र User-Agent के अंतर को पकड़कर तुरंत 429 लौटाना।
  2. लेयर 2: API गेटवे (Kong, Envoy, Nginx): टोकन बकेट (Token Bucket) और लीकी बकेट (Leaky Bucket) अल्गोरिदम।
  3. लेयर 3: ओरिजिन सर्वर: डेटाबेस और सर्वर ओवरलोड सुरक्षा।

महत्वपूर्ण रिस्पांस हेडर्स:

हेडर विनिर्देश (Specification) वैल्यू फॉर्मेट विवरण
Retry-After RFC 7231 / RFC 9110 सेकंड (120) या HTTP-date दोबारा प्रयास करने से पहले अनिवार्य प्रतीक्षा अवधि
RateLimit-Limit IETF Draft पूर्णांक (100) वर्तमान विंडो में कुल कोटा सीमा
RateLimit-Remaining IETF Draft पूर्णांक (0) वर्तमान विंडो में शेष बची हुई यूनिट्स
RateLimit-Reset IETF Draft सेकंड या Epoch टाइमस्टैम्प कोटा रीसेट होने तक शेष समय

3. Cloudflare 520 एरर के कारण

520 एरर का मतलब है कि ओरिजिन सर्वर ने अप्रत्याशित रिस्पांस भेजा:

  1. सर्वर प्रोसेस क्रैश (OOM / SIGSEGV): अत्यधिक क्रॉलर कॉल्स से मेमोरी समाप्त होना और TCP RST पैकेट ट्रिगर होना।
  2. Keep-Alive टाइमआउट मिसमैच: Cloudflare कनेक्शन 15 सेकंड रखता है, यदि Nginx 5 सेकंड में बंद कर दे तो एरर 520 आता है।
  3. बड़ा हेडर साइज़ (>16KB): अत्यधिक कुकीज़ हेडर बफर को पार कर जाती हैं।
  4. शून्य बाइट रिस्पांस: बिना डेटा भेजे कनेक्शन का बंद होना।

4. समाधान: Decorrelated Jitter और सर्किट ब्रेकर

साधारण री-ट्राई लूप्स थंडरिंग हर्ड (Thundering Herd) समस्या को जन्म देते हैं। सबसे बेहतरीन समाधान है AWS द्वारा समर्थित Decorrelated Jitter: 

# Decorrelated Jitter फ़ॉर्मूला:
sleep = min(cap, random.uniform(base, previous_delay * 3.0))

सर्किट ब्रेकर के साथ Python कार्यान्वयन

import asyncio, random, time, aiohttp
from urllib.parse import urlparse

class ResilientAgentCrawler:
    def __init__(self, base_delay=1.0, max_delay=60.0, max_retries=5, threshold=4, cooldown=30.0):
        self.base_delay = base_delay
        self.max_delay = max_delay
        self.max_retries = max_retries
        self.threshold = threshold
        self.cooldown = cooldown
        self.failures = {}
        self.opened_at = {}

    def _is_open(self, domain):
        t = self.opened_at.get(domain)
        if not t: return False
        if time.monotonic() - t > self.cooldown:
            del self.opened_at[domain]
            self.failures[domain] = 0
            return False
        return True

    async def fetch(self, session, url):
        domain = urlparse(url).netloc
        if self._is_open(domain):
            raise RuntimeError(f"सर्किट ब्रेकर एक्टिव है: {domain}")

        delay = self.base_delay
        for attempt in range(1, self.max_retries + 1):
            try:
                async with session.get(url) as resp:
                    if resp.status == 200:
                        self.failures[domain] = 0
                        return await resp.text()
                    elif resp.status == 429:
                        retry_after = resp.headers.get("Retry-After")
                        wait = float(retry_after) if retry_after else random.uniform(self.base_delay, delay * 3.0)
                        delay = min(self.max_delay, wait)
                        await asyncio.sleep(delay)
                    elif resp.status in (520, 502, 503, 504):
                        self.failures[domain] = self.failures.get(domain, 0) + 1
                        if self.failures[domain] >= self.threshold:
                            self.opened_at[domain] = time.monotonic()
                        delay = min(self.max_delay, random.uniform(self.base_delay, delay * 3.0))
                        await asyncio.sleep(delay)
                    else:
                        resp.raise_for_status()
            except Exception as e:
                if attempt == self.max_retries: raise e
                await asyncio.sleep(delay)

5. curl_cffi के ज़रिए TLS JA4 फ़िंगरप्रिंट बायपास

2026 में केवल User-Agent बदलना पर्याप्त नहीं है। curl_cffi का उपयोग करके Chrome की वास्तविक TLS और HTTP/2 सेटिंग्स का अनुकरण करें: 

from curl_cffi.requests import AsyncSession

async def fetch_stealth(url: str):
    async with AsyncSession(impersonate="chrome124") as s:
        res = await s.get(url, timeout=15)
        return res.text

6. प्रॉक्सी पूल और Nginx कॉन्फ़िगरेशन

  • रोटेटिंग रेजिडेंशियल प्रॉक्सी: हज़ारों घरेलू IP पतों पर ट्रैफिक बांटकर 429 एरर को रोकते हैं।
  • मोबाइल 4G/5G प्रॉक्सी (CGNAT): सबसे प्रभावी, क्योंकि एक IP हज़ारों आम यूज़र्स के साथ साझा होता है।
  • एरर 520 को रोकने के लिए Nginx सेटिंग्स:
http {
    keepalive_timeout 75s;
    keepalive_requests 10000;
    proxy_buffer_size 128k;
    proxy_buffers 4 256k;
}

स्क्रैपिंग इंफ्रास्ट्रक्चर की तुलना

फीचर / मीट्रिक सेल्फ-मैनेज्ड Playwright फ़्लीट Crawl4AI (सेल्फ-होस्टेड) Firecrawl / Tavily API Bright Data Scraping Browser
होस्टिंग लागत उच्च ($500–$5k/माह VM) मध्यम ($100–$800/माह) उपयोग आधारित (प्रति अनुरोध) उपयोग आधारित ($1.50–$3/GB)
रखरखाव प्रयास बहुत अधिक (पैच, फ़िंगरप्रिंट) मध्यम (Docker/Python) शून्य (पूरी तरह प्रबंधित) न्यूनतम (CDP एंडपॉइंट्स)
429 रोकथाम मैन्युअल (बैकऑफ़ + प्रॉक्सी) अर्ध-स्वचालित पूर्ण स्वचालित (आंतरिक कतार) पूर्ण स्वचालित
Cloudflare बायपास कस्टम समाधान आवश्यक स्टील्थ ड्राइवर सक्षम 96–99% सफलता दर 98–99.5% सफलता दर

7. ट्रबलशूटिंग मैट्रिक्स

लक्षण (Symptom) मूल कारण (Root Cause) इंजीनियरिंग समाधान
पहले ही अनुरोध पर 429 TLS फ़िंगरप्रिंट (JA4) या HTTP/2 फ़्रेम मिसमैच मानक क्लाइंट बदलकर curl_cffi (impersonating chrome124) या Camoufox उपयोग करें।
ठीक 60 अनुरोधों के बाद 429 ओरिजिन टोकन बकेट / लीकी बकेट रेट लिमिटर ट्रिगर क्लाइंट-साइड टोकन बकेट कतार बनाएं; प्रति सेशन रेजिडेंशियल IP रोटेट करें।
पीक लोड पर Cloudflare 520 बैकएंड वर्कर क्रैश (PHP-FPM/Gunicorn OOM) वर्कर मेमोरी सीमाएं बढ़ाएं; asyncio.Semaphore से समवर्ती अनुरोध सीमित करें।
रैंडम 520 टाइमआउट Cloudflare और Nginx के बीच Keep-Alive मिसमैच ओरिजिन Nginx keepalive_timeout को 75s (Cloudflare के 15s से अधिक) पर सेट करें।

8. निष्कर्ष

AI क्रॉलर्स को निर्बाध चलाने के नियम:

  1. Decorrelated Jitter का उपयोग करें।
  2. curl_cffi से असली ब्राउज़र फ़िंगरप्रिंट का अनुकरण करें।
  3. ओरिजिन सर्वर पर Keep-Alive को 75 सेकंड पर सेट करें।
  4. सर्किट ब्रेकर लगाकर टोकन खर्च और समय बचाएं।
← सभी लेख
0 / 4
अभी तुलना करें →