साइटमैप-प्रेरित क्रॉलिंग: उन्हें लाने से पहले यूआरएल खोजें

TL;DR:

• ज्यादातर क्रॉलर URLs का पता लिंक फॉलो करके लगाते हैं, जिसका मतलब है कि आपको उन पृष्ठों को लाना होता है जिन्हें आप नहीं चाहते ताकि आप उन्हें पा सकें जिन्हें आप चाहते हैं।
• एक साइटमैप आपको पहले से सूची प्रदान करता है: एक HTTP अनुरोध हर URL को वापस करता है जिसे साइट अनुक्रमित करना चाहती है, जो पहले से ही प्रकाशक द्वारा डुप्लीकेट किया गया है।
• इस गाइड में एक वास्तविक साइटमैप को फ़िल्टर करने से 7,577 प्रविष्टियों को 597 तक काटा गया जो लक्षित खंड से मेल खाती हैं, बिना एक भी पृष्ठ लाए।
• उस सूची से एक स्पष्ट क्रॉल बजट सेट करें न कि crawling until something stops you — सीमा कोड में होनी चाहिए, आपके इरादों में नहीं।
• केवल तब जावास्क्रिप्ट का उपयोग करें जब डेटा को इसकी आवश्यकता हो; इस वॉकथ्रू में पृष्ठ अपने शीर्षकों को सर्वर-साइड पर प्रदर्शित करते हैं, इसलिए एक गैर-प्रदर्शित फेच तेज़ है और वही फ़ील्ड लौटाता है।
• Scrapeless मुफ्त योजना पर शुरू करें और खोज चरण को एक साइटमैप की ओर इंगित करें जिसे आप क्रॉल करने की अनुमति रखते हैं।

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

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

साइटमैप आपको क्या देता है

एक साइटमैप एक XML फ़ाइल है जो साइट के URLs की सूची देती है, जिसे साइटमैप प्रोटोकॉल द्वारा परिभाषित किया गया है। दो आकार हैं और आपको दोनों को संभालना होता है:

• एक urlset <url><loc> प्रविष्टियाँ रखता है जो पृष्ठों की ओर इशारा करती हैं।
• एक sitemapindex <sitemap><loc> प्रविष्टियाँ रखता है जो अन्य साइटमैप्स की ओर इशारा करती हैं, जब एक साइट प्रोटोकॉल की 50,000-URL या 50 MB सीमा प्रति फ़ाइल से अधिक होती है।

दोनों वही <loc> तत्व का उपयोग करते हैं, यही कारण है कि नीचे दिया गया पार्सर <loc> पढ़ता है और फिर यह तय करता है कि यह क्या देख रहा है। साइटमैप्स को आमतौर पर gzipped के रूप में भी परोसा जाता है, इसलिए एक फेचर को इसे पारदर्शी रूप से हैंडल करना चाहिए।

इसे खोजने के लिए: पहले /sitemap.xml जांचें, फिर robots.txt के भीतर Sitemap: निर्देश, जिसे रोबोट्स निषेध प्रोटोकॉल मानक द्वारा इसे विज्ञापित करने के लिए मानक स्थान के रूप में परिभाषित किया गया है।

पूर्वापेक्षाएँ

• Python 3.9 या बाद का संस्करण। खोज चरण केवल मानक पुस्तकालय का उपयोग करता है।
• फ़ेच चरण के लिए एक Scrapeless API कुंजी:

export SCRAPELESS_API_KEY="your_api_key_here"

नीचे दिए गए उदाहरण Scrapeless साइटमैप को इंगित करते हैं, इसलिए वॉकथ्रू को ठीक उसी तरह चलाना सुरक्षित है जैसा लिखा गया है। जब आप इसे अनुकूलित करते हैं तो एक साइटमैप स्वैप करें जिसे आप क्रॉल करने की अनुमति रखते हैं।

खोजें और फ़िल्टर करें

एक अनुरोध, फिर मेमोरी में फ़िल्टरिंग। अभी तक साइट से कुछ भी नहीं लाया गया है:

import gzip, re, urllib.request

SITEMAP = "https://www.scrapeless.com/sitemap.xml"
LOC_RE = re.compile(r"<loc>\s*([^<\s]+)\s*</loc>", re.I)

def fetch_xml(url: str) -> str:
    req = urllib.request.Request(url, headers={"User-Agent": "sitemap-demo/1.0"})
    with urllib.request.urlopen(req, timeout=60) as r:
        raw = r.read()
    if url.endswith(".gz") or raw[:2] == b"\x1f\x8b":
        raw = gzip.decompress(raw)
    return raw.decode("utf-8", errors="replace")

xml = fetch_xml(SITEMAP)
is_index = "<sitemapindex" in xml.lower()
urls = LOC_RE.findall(xml)

print(f"document type: {'sitemap index' if is_index else 'url set'}")
print(f"total <loc> entries: {len(urls)}")

blog = sorted({u for u in urls if "/en/blog/" in u})
print(f"filtered to /en/blog/: {len(blog)}")
print(f"first: {blog[0]}")

document type: url set
total <loc> entries: 7,577
filtered to /en/blog/: 597
first: https://www.scrapeless.com/hi/blog/10-best-no-code-web-scrapers

यह इस दृष्टिकोण के लिए पूरा तर्क है: 7,577 URLs सूचीबद्ध किए गए और 597 प्रासंगिक तक संकुचित किया गया, केवल एक अनुरोध की कीमत पर। एक लिंक-फॉलोइंग क्रॉलर ने समान सूची तक पहुँचने के लिए सैकड़ों पृष्ठों को लाया होगा, और अभी भी कुछ भी मिस कर जाएगा जो उस पथ से लिंक नहीं किया गया था जिसे उसने चलाया।

कोड में तीन विवरण महत्वपूर्ण हैं।

gzip जांच जादुई बाइट्स की जांच करती है न कि फ़ाइल के विस्तार पर भरोसा करती है, क्योंकि बहुत सारे सर्वर .xml URL से gzipped सामग्री लौटाते हैं। जो दो-बाइट \x1f\x8b सिग्नेचर खोजना है वह हेडर है जिसे GZIP फ़ाइल प्रारूप विनिर्देश में परिभाषित किया गया है।

sorted({...}) एक सेट संकल्पना है, इसलिए डुप्लिकेट URLs को गिनने से पहले संकुचित किया जाता है। साइटमैप में डुप्लिकेट होते हैं, विशेष रूप से जब एक साइट को कई जनरेटर से जोड़ा जाता है।

<sitemapindex> का पता लगाना महत्वपूर्ण है क्योंकि एक इंडेक्स का मतलब है कि <loc> मान जो आपने अभी एकत्रित किए हैं वे अधिक साइटमैप्स हैं, पृष्ठ नहीं। यदि is_index सत्य है, तो उनकी प्रत्येक फ़ेच करें और दोहराएं इससे पहले कि किसी भी चीज़ को पृष्ठ URL के रूप में माना जाए।

एक स्पष्ट बजट सेट करें, फिर फ़ेच करें

अनुवाद:

खोज सस्ती है; लाना नहीं। आप जो पृष्ठ प्राप्त करेंगे, वह कोड में एक स्थिरांक होना चाहिए, न कि इस बात की उभरती संपत्ति कि लूप कितनी देर तक चलता है:

import json, os, re, urllib.request

SITEMAP = "https://www.scrapeless.com/sitemap.xml"
API = "https://api.scrapeless.com/api/v2/unlocker/request"
LOC_RE = re.compile(r"<loc>\s*([^<\s]+)\s*</loc>", re.I)
TITLE_RE = re.compile(r"<title[^>]*>(.*?)</title>", re.S | re.I)

def fetch_sitemap(url: str) -> str:
    req = urllib.request.Request(url, headers={"User-Agent": "sitemap-demo/1.0"})
    with urllib.request.urlopen(req, timeout=60) as r:
        return r.read().decode("utf-8", errors="replace")

def fetch_page(url: str) -> str:
    body = json.dumps({
        "actor": "unlocker.webunlocker",
        "input": {"url": url, "js_render": False},
    }).encode()
    req = urllib.request.Request(API, data=body, headers={
        "x-api-token": os.environ["SCRAPELESS_API_KEY"],
        "Content-Type": "application/json",
    })
    with urllib.request.urlopen(req, timeout=180) as r:
        return json.loads(r.read())["data"]

urls = sorted({u for u in LOC_RE.findall(fetch_sitemap(SITEMAP)) if "/en/blog/" in u})
print(f"फ़िल्टर और डिडुप्लिकेट के बाद उम्मीदवार: {len(urls)}")

BUDGET = 3
print(f"क्रॉल बजट: {BUDGET}")

for url in urls[:BUDGET]:
    html = fetch_page(url)
    m = TITLE_RE.search(html)
    title = re.sub(r"<[^>]+>", "", m.group(1)).strip() if m else "(कोई शीर्षक नहीं)"
    print(f"  {url.rsplit('/', 1)[-1]} -> {title}")

फ़िल्टर और डिडुप्लिकेट के बाद उम्मीदवार: 597
क्रॉल बजट: 3
  10-best-no-code-web-scrapers -> 10 बेहतरीन नो-कोड वेब स्क्रेपर जो 2025 में प्रयास रहित डेटा निकासी के लिए हैं
  20-ways-for-web-scraping-without-getting-blocked -> बिना रोके वेब स्क्रैपिंग के लिए 20 तरीके
  403-web-scraping -> वेब स्क्रैपिंग में त्रुटि 403: अवरोधित अनुरोधों को ठीक करने के लिए 10 आसान समाधान

BUDGET एक नामित स्थिरांक है जिसे एक स्लाइस के साथ लागू किया गया है। यह जानबूझकर है: एक क्रॉलर जिसकी रुकने की स्थिति "सूची खत्म हो गई" है, वह कुछ सैकड़ों-यूआरएल अनुभाग पर बहुत अलग व्यवहार करता है बनाम उस पर जिसमें हजारों हैं, और यह अंतर केवल उत्पादन में सामने आता है।

ध्यान दें कि js_render को False पर सेट किया गया है। ये पृष्ठ अपनी <title> प्रारंभिक HTML में प्रदान करते हैं, इसलिए रेंडरिंग एक ऐसे क्षेत्र के लिए लागत और विलंब जोड़ देगी जो पहले से ही वहां है। तब रेंडर करें जब आपको जो डेटा चाहिए वह एक स्क्रिप्ट द्वारा DOM में लिखा गया हो — डिफ़ॉल्ट रूप से नहीं। Scrapeless यूनिवर्सल स्क्रैपिंग API दोनों को संभालती है, और JS रेंडरिंग गाइड बताती है कि आप किस मामले में हैं।

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

समस्या निवारण

/sitemap.xml 404 लौटाता है। robots.txt पढ़ें और एक Sitemap: पंक्ति की तलाश करें, जो पूरी तरह से कहीं और इशारा कर सकती है। कुछ साइटें केवल वहाँ एक प्रकाशित करती हैं; कुछ बिल्कुल भी नहीं प्रकाशित करतीं, जिस स्थिति में लिंक-फॉलोइंग आपका शेष विकल्प है।

पार्सर एक वैध-दिखने वाली फ़ाइल से शून्य URL लौटाता है। जांचें कि क्या प्रतिक्रिया gzipped थी और अंडरकॉम्प्रेस्ड नहीं थी — ऊपर दिए गए जादुई-बाइट चेक सामान्य मामले को संभालता है। यह भी सुनिश्चित करें कि आपने XML प्राप्त किया है और कोई HTML त्रुटि पृष्ठ नहीं, जो एक मित्रवत 404 पर रीडायरेक्ट करने पर उत्पन्न होता है।

गिनती बहुत कम लगती है। दस्तावेज़ संभवतः एक साइटमैप इंडेक्स है। इसमें हर <loc> एक अन्य साइटमैप है जिसे लाना है, और पृष्ठ URL एक स्तर नीचे हैं।

एन्ट्रीज़ उन URLs की ओर इशारा करती हैं जो अब अस्तित्व में नहीं हैं। साइटमैप जेनरेट होते हैं, और जनरेटर्स पीछे रह जाते हैं। सूची को उम्मीदवारों के रूप में मानें न कि गारंटी के रूप में, और कुछ एन्ट्रीज़ से 404 लौटने की उम्मीद करें।

किसी भी चीज़ को क्रॉल करने से पहले साइट की शर्तें और इसकी robots.txt की जांच करें, संग्रह को सार्वजनिक पृष्ठों तक सीमित रखें, और बजट को उस अनुपात में रखें जिसे साइट आराम से सर्व कर सकती है। एक साइटमैप आपको बताता है कि एक प्रकाशक क्या अनुक्रमित करवाने के लिए तैयार है; यह उसे तेजी से लेने का लाइसेंस नहीं है।

निष्कर्ष

साइटमैप-चालित क्रॉलिंग एक क्रॉलर के सबसे बर्बादी वाले हिस्से — खोज — को एकल अनुरोध के साथ बदल देती है। इस वॉकथ्रू में इसका मतलब 7,577 URLs की गणना करना, 597 जो महत्वपूर्ण थे, तक संकीर्ण करना, और केवल 3 लाना था, जिसमें बंधन कोड में लिखा गया था न कि मौका पर छोड़ दिया गया था।

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

प्रश्नोत्तर

प्रश्न: मैं एक वेबसाइट का साइटमैप कैसे खोजूं?

पहले /sitemap.xml आजमाएँ, फिर robots.txt पढ़ें एक Sitemap: निर्देश के लिए, जिसे RFC 9309 एक प्रमाणिक स्थान के रूप में परिभाषित करता है विज्ञापित करने के लिए। बड़े साइट अक्सर उस पथ पर एक अनुक्रम प्रकाशित करते हैं जो कई अनुभाग साइटमैप्स को एकल स्तर की फ़ाइल के बजाय इंगित करता है।

प्रश्न: साइटमैप इंडेक्स और URL सेट में क्या अंतर है?

एक URL सेट पृष्ठ URLs की सूची बनाता है; एक साइटमैप इंडेक्स अन्य साइटमैप फ़ाइलों की सूची बनाता है। दोनों <loc> तत्वों का उपयोग करते हैं, इसलिए एक पार्सर जो केवल <loc> देखता है, खुशी-खुशी साइटमैप URLs लौटाएगा जबकि आप सोचते हैं कि आपके पास पृष्ठ हैं। <sitemapindex> मूल तत्व के लिए जांचें और जब आप एक पाएं, तो पुनरावृत्ति करें - विभाजन इसलिये है क्योंकि प्रोटोकॉल एकल फ़ाइल को 50,000 URLs या 50 MB पर सीमित करता है।

प्रश्न: क्या साइटमैप से क्रॉल करना लिंक का अनुसरण करने से बेहतर है?

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

प्रश्न: क्या मुझे साइटमैप से क्रॉल करते समय जावास्क्रिप्ट रेंडर करनी चाहिए?

केवल जब जिस फ़ील्ड की आपको आवश्यकता हो, वह प्रारंभिक HTML में न हो। इस वॉकथ्रू में पृष्ठ अपने <title> को सर्वर-साइड पर प्रदान करते हैं, इसलिए js_render को False पर सेट किया गया है और फ़ेच सस्ता और तेज़ है। पहले एक पृष्ठ की जांच करें: यदि डेटा दृश्य-स्रोत में दिखाई देता है, तो आपको रेंडरिंग की आवश्यकता नहीं है।

प्रश्न: मुझे प्रति रन कितने पृष्ठों को फ़ेच करना चाहिए?

एक संख्या को स्पष्ट रूप से सेट करें और उम्मीदवार सूची को उस तक काटें, जैसा कि BUDGET ऊपर करता है। सही मान साइट की क्षमता और आपकी आवश्यकताओं पर निर्भर करता है, लेकिन महत्वपूर्ण हिस्सा यह है कि यह एक ऐसा निर्णय है जो कोड में दर्ज किया गया है न कि सूची की लंबाई का एक साइड इफेक्ट - जो एक छोटे से अनुभाग के काम और एक पूरे-साइट के काम को बहुत अलग घटनाओं में बदल देता है।