मुख्य बिंदु:

• कोई एकल आदेश नहीं है जो हर पृष्ठ को सूचीबद्ध करे। एक पूर्ण URL सूची विभिन्न तरीकों के संयोजन से आती है: एक त्वरित अनुमान के लिए site: खोज ऑपरेटर, जो साइट प्रकाशित करती है उसके लिए sitemap.xml और साइटमैप इंडेक्स, प्रवेश बिंदुओं के लिए robots.txt साइटमैप निर्देश, जो कुछ वास्तव में लिंक किए गए हैं उसके लिए एक SEO क्रॉलर या एक पायथन क्रॉलर, और क्लाइंट-साइड लिंक के लिए एक क्लाउड ब्राउज़र जो केवल तब दिखाई देते हैं जब जावास्क्रिप्ट चलती है।
• साइटमैप सबसे तेज प्राधिकृत स्रोत हैं — जब वे मौजूद हों और वर्तमान रहें। एक सिंगल requests.get("/sitemap.xml") के साथ किसी भी साइटमैप इंडेक्स की पुनरावृत्त यात्रा एक बार में सैकड़ों URLs लौटा सकती है।
• एक चौड़ाई-प्रथम क्रॉलर वह खोजता है जो साइटमैप छोडता है। साइटमैप लेखक-प्रभूत होते हैं और अक्सर पुराने होते हैं; आंतरिक <a href> लिंक का BFS यात्रा अनाथ पृष्ठों, गहरे लिंक वाले सामग्री और अन्य किसी भी चीज़ को खोजती है जिसे साइटमैप ने भुला दिया। इस गाइड में क्रॉलर हर URL को प्राप्त करने से पहले robots.txt Disallow नियमों का सम्मान करता है।
• जावास्क्रिप्ट-जनित लिंक के लिए एक वास्तविक ब्राउज़र की आवश्यकता होती है। सिंगल-पेज ऐप्स और अनंत-स्क्रॉल कैटलॉग अपने आंतरिक लिंक को क्लाइंट-साइड चित्रित करते हैं, इसलिए सामान्य HTTP फ़ेच एक लगभग खाली शेल लौटाता है। Scrapeless Scraping Browser पृष्ठ को एक क्लाउड ब्राउज़र में रेंडर करता है, फिर आप हाइड्रेटेड DOM से एंकर इकट्ठा करते हैं — US आवासीय एग्रेस पर सत्र आयोजित करते हुए।
• शुरू करने के लिए स्वतंत्र। नए Scrapeless खाते मुफ्त Scraping Browser रनटाइम के साथ आते हैं — app.scrapeless.com पर साइन अप करें।

परिचय: क्यों पूर्ण URL सूची बनाना उतना आसान नहीं है जितना लगता है

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

मौजूदा विकल्प प्रत्येक एक कतरन को कवर करते हैं। Google site: ऑपरेटर एक तेज सार्वजनिक अनुमान देता है लेकिन परिणामों को सीमित करता है और केवल उन्हीं चीजों को दर्शाता है जो अनुक्रमित हैं। एक sitemap.xml उन पृष्ठों के लिए प्राधिकृत है जिन्हें प्रकाशक ने घोषित करने का निर्णय लिया, लेकिन यह पुराना हो जाता है और उन पृष्ठों को छोड़ता है जिन्हें CMS ने कभी पंजीकृत नहीं किया। एक क्रॉलर जो लिंक का पालन करता है लिंक ग्राफ को खोजता है, लेकिन एक साधारण HTTP क्रॉलर जावास्क्रिप्ट-भारी पृष्ठों पर एक खाली शेल लौटाता है जहां नेविगेशन क्लाइंट-साइड रेंडर किया जाता है।

यह गाइड छः तरीकों के माध्यम से चलाता है लागत और पूर्णता के क्रम में — पहले सस्ते और तेज, और अंत में व्यापक और रेंडर किया गया। पायथन उदाहरण स्थिर स्तरों के लिए requests और मानक पुस्तकालय का उपयोग करते हैं, और जावास्क्रिप्ट स्तर के लिए Scrapeless Scraping Browser के माध्यम से एक क्लाउड ब्राउज़र, ताकि क्लाइंट-साइड लिंक खोजने योग्य हों। US एग्रेस को पिन करें, पृष्ठ को रेंडर करें, एंकर इकट्ठा करें। सहायक गाइड के लिए क्रॉस-लिंक अंत में हैं।

आप इसके साथ क्या कर सकते हैं

• तकनीकी SEO ऑडिट। हर अनुक्रमणीय URL को सूचीबद्ध करें, फिर साइटमैप के खिलाफ क्रॉल का अंतर करें ताकि अनाथ पृष्ठों और साइटमैप द्वारा भुलाए गए पृष्ठों को सतह पर लाया जा सके।
• सामग्री प्रवास। एक पुनर-प्लेटफॉर्म से पहले पूर्ण स्रोत-URL सूची बनाएं ताकि कटओवर के बाद कुछ भी 404 न हो, और पुरानी पथों को नए रास्तों के साथ मानचित्रित करें।
• टूटी लिंक स्वीप। आंतरिक लिंक ग्राफ पर चलें, हर गंतव्य को रिकॉर्ड करें, और उन्हें चिह्नित करें जो गैर-200 स्थिति लौटाते हैं।
• मूल्य और कैटलॉग निगरानी। एक खुदरा विक्रेता पर हर उत्पाद URL खोजें — जावास्क्रिप्ट-जनित लोगों सहित — और उन्हें एक डाउनस्ट्रीम निष्कर्षण पाइपलाइन में खिलाएं।
• LLM कॉर्पस भक्षण। पूर्ण सामग्री URLs का एक सेट तैयार करें ताकि एक पाठ-निष्कर्षण कार्य पूरी सार्वजनिक कॉर्पस को बिना गहरे लिंक वाले लेखों को छोड़कर खींच सके।
• प्रतिस्पर्धी सामग्री मानचित्रण। प्रतियोगी के सार्वजनिक अनुभाग संरचना की सूची बनाएं साइटमैप और लिंक ग्राफ से उनकी सामग्री के पदचिह्न को आकार देने के लिए।

क्यों Scrapeless Scraping Browser

इस गाइड का अधिकांश भाग पायथन मानक पुस्तकालय और requests पर चलता है — साइटमैप और robots.txt सामान्य पाठ और XML हैं, और एक स्थिर लिंक क्रॉलर को और कुछ भी नहीं चाहिए। Scrapeless Scraping Browser एक अनुकूलनशील, एंटी-डिटेक्शन क्लाउड ब्राउज़र है जो वेब क्रॉलरों और AI एजेंटों के लिए डिज़ाइन किया गया है; यह वह स्तर है जिसे आप तब तक पहुँचते हैं जब आपके द्वारा आवश्यक लिंक केवल जावास्क्रिप्ट चलने के बाद मौजूद होते हैं। विशिष्ट रूप से पूर्ण-साइट URL खोज के लिए, यह लाता है:

• क्लाउड-साइड जावास्क्रिप्ट रेंडरिंग, ताकि सिंगल-पेज ऐप, अनंत-स्क्रॉल कैटलॉग, या React/Vue/Next.js नेविगेशन पर आंतरिक लिंक उस DOM में दिखाई दे — न कि एक खाली <div id="root"> के रूप में।
• US आवासीय प्रॉक्सी एग्रेस, सत्र के अनुसार पिन किया गया, ताकि भू-गेटेड साइटें वही पृष्ठ संरचना सर्व करें जो वे एक US आगंतुक को सेवा देती हैं।
• एंटी-डिटेक्शन फ़िंगरप्रिंटिंग हर सत्र में, ताकि रेंडर किया गया पृष्ठ उस चीज़ से मेल खाता हो जो जैविक ट्रैफ़िक देखता है, बजाय एक झंडा लगाए गए स्वचालन प्रोफ़ाइल के।
• सत्र निरंतरता एक वार्म-अप नेविगेशन और लक्ष्य पृष्ठ के बीच, इसलिए एक होमपेज विज़िट जो कुकीज़ सेट करता है वह उस पृष्ठ पर ले जाती है जिसे आप वास्तव में सूचीबद्ध करना चाहते हैं।
• एक एंडपॉइंट, मानक CDP, इसलिए प्ले राइट (या कोई भी क्रोम डेव टूल्स प्रोटोकॉल क्लाइंट) वेब-सॉकेट के माध्यम से कनेक्ट करता है बिना किसी स्थानीय ब्राउज़र के जो रेंडरिंग करता है।

अपना API कुंजी मुफ्त योजना पर प्राप्त करें app.scrapeless.com पर।

आवश्यकताएँ

• पायथन 3.10 या नया।
• एक Scrapeless खाता और API कुंजी — app.scrapeless.com पर साइन अप करें।
• pip install requests playwright और playwright install chromium (स्थानीय क्रोमियम केवल CDP प्रोटोकॉल क्लाइंट है; रेंडरिंग Scrapeless के क्लाउड में होती है)।
• टर्मिनल और HTTP की बुनियादी जानकारी।

विधि 1 — Google site: खोज ऑपरेटर

सबसे तेज़ पहला अनुमान किसी कोड की आवश्यकता नहीं है। इसे Google में टाइप करें:

site:example.com

Google उस होस्ट के लिए जिसे उसने अनुक्रमित किया है, पृष्ठ लौटाता है, और परिणामों का शीर्षक एक अनुमानित संख्या दिखाता है। इसे अनुभाग संरचना को मैप करने के लिए संकीर्ण करें:

• site:example.com/blog — केवल /blog के तहत URL।
• site:example.com inurl:product — अनुक्रमित URL जिनका पथ product को शामिल करता है।
• site:example.com -inurl:tag — एक पथ खंड को छोड़ें जो आपको परवाह नहीं है।

यह विधि किसके लिए अच्छी है: साइट का आकार और कौन से अनुभाग मौजूद हैं उसका तीस सेकंड का अनुभव। यह नहीं होने के लिए अच्छी है: पूर्णता। site: ऑपरेटर केवल उन पृष्ठों को दर्शाता है जिन्हें Google ने अनुक्रमित करने का निर्णय लिया है, परिणाम संख्या एक अनुमान है न कि एक सटीक आंकड़ा, और ऑपरेटर यह सीमित करता है कि आप कितने परिणाम पृष्ठ के माध्यम से देख सकते हैं। इसे नीचे दी गई अधिक गहन विधियों के खिलाफ एक संतुलन जांच के रूप में मानें — यदि आपका साइटमैप 5,000 URL की घोषणा करता है और site: लगभग 200 दिखाता है, तो वह अंतर अपने आप में एक खोज है।

विधि 2 — sitemap.xml और साइटमैप इंडेक्स को पार्स करें

एक साइटमैप प्रकाशक के अपने URL की घोषणा है, जिसे XML के रूप में एक पारंपरिक पथ पर /sitemap.xml के रूप में प्रदान किया जाता है। जब यह मौजूद हो और वर्तमान हो, तो यह सबसे तेज़ प्राधिकृत स्रोत है। दो रूप महत्वपूर्ण हैं:

• एक <urlset> साइटमैप पृष्ठ URL सीधे सूचीबद्ध करता है, प्रत्येक पृष्ठ के लिए एक <url><loc>…</loc></url>।
• एक <sitemapindex> अन्य साइटमैप्स की सूची बनाता है — बड़े साइट अपने URL को बच्चे फ़ाइलों (pages_sitemap.xml, blog_sitemap.xml, आदि) के बीच विभाजित करते हैं और एक इंडेक्स से उन पर संकेत करते हैं। आप इंडेक्स को चलते हैं, फिर प्रत्येक बच्चे पर चलते हैं।

यह requests स्क्रिप्ट एकल पुनरावृत्ति फ़ंक्शन के साथ दोनों रूपों को संभालती है। यह मूल टैग का पता लगाती है, एक साइटमैप इंडेक्स में पुनरावृत्त होती है, और प्रत्येक <urlset> से पृष्ठ URL एकत्र करती है:

import requests
import xml.etree.ElementTree as ET
from urllib.parse import urljoin

SM_NS = "{http://www.sitemaps.org/schemas/sitemap/0.9}"
HEADERS = {"User-Agent": "Mozilla/5.0 (sitemap-discovery)"}

def walk_sitemap(url, seen=None):
    """एक साइटमैप या साइटमैप इंडेक्स से हर पृष्ठ URL लौटाएं।"""
    seen = seen if seen is not None else set()
    if url in seen:          # एक साइटमैप के खिलाफ जो खुद को संदर्भित करता है
        return []
    seen.add(url)

    resp = requests.get(url, headers=HEADERS, timeout=30)
    resp.raise_for_status()
    root = ET.fromstring(resp.content)
    tag = root.tag.split("}")[-1]   # उपन्यास स्थान को स्ट्रिप करें, "sitemapindex" या "urlset" रखें

    urls = []
    if tag == "sitemapindex":
        # एक इंडेक्स बच्चे साइटमैप की ओर इशारा करता है — प्रत्येक में पुनरावृत्ति करें।
        for sm in root.findall(f"{SM_NS}sitemap"):
            loc = sm.findtext(f"{SM_NS}loc")
            if loc:
                urls.extend(walk_sitemap(loc.strip(), seen))
    else:
        # एक urlset सीधे पृष्ठ URL को सूचीबद्ध करता है।
        for u in root.findall(f"{SM_NS}url"):
            loc = u.findtext(f"{SM_NS}loc")
            if loc:
                urls.append(loc.strip())
    return urls

if __name__ == "__main__":
    pages = walk_sitemap("https://example.com/sitemap.xml")
    print(f"साइटमैप पेड़ से {len(pages):,} URLs की खोज की गई")
    for u in pages[:10]:
        print(" ", u)

एक ऐसी साइट के खिलाफ चलाने पर जिसका /sitemap.xml एक साइटमैप इंडेक्स है जो बच्चे साइटमैप की ओर इशारा करता है, पुनरावृत्त चलान हर बच्चे साइटमैप का संघ एकल पास में लौटाता है।

जंगली में साइटमैप पर कुछ नोट्स:

• पथ एक पारंपरिकता है, गारंटी नहीं। /sitemap.xml सामान्य स्थान है, लेकिन एक साइट इसे कुछ भी नाम दे सकती है और robots.txt में असली पथ की घोषणा कर सकती है (विधि 3)। फ़ाइल के अस्तित्व का अनुमान लगाने से पहले हमेशा robots.txt की जांच करें।
• संपीड़ित साइटमैप मौजूद हैं। कुछ साइटें sitemap.xml.gz परोसती हैं; requests स्वचालित रूप से .gz शरीर को डिकंप्रेस नहीं करता है, इसलिए यदि आप किसी पर हिट करते हैं तो इसे gzip मॉड्यूल के साथ पार्स करने से पहले डिकंप्रेस करें।
• साइटमैप बासी हो जाते हैं। ये उस समय का प्रतिबिंब हैं जब CMS ने पंजीकरण किया था। आखिरी निर्माण के बाद जोड़े गए पृष्ठ और अनाथ पृष्ठ जो CMS ने कभी पंजीकरण नहीं किया, उनमें से कोई होगा – यही कारण है कि विधियाँ 5 और 6 मौजूद हैं।

विधि 3 — robots.txt साइटमैप निर्देश पढ़ें

कुछ भी क्रॉल करने से पहले, /robots.txt लाएँ। यह URL खोज के लिए दो उद्देश्यों की पूर्ति करता है: यह अक्सर एक या एक से अधिक Sitemap: पंक्तियों के साथ साइटमैप स्थानों की घोषणा करता है, और यह आपको यह बताता है कि साइट क्रॉवलर्स से कौन से पथों को अकेला छोड़ने के लिए कहती है (Disallow:)। दोनों महत्वपूर्ण हैं — पहला विधि 2 को फीड करता है, दूसरा एक अनुपालन दायित्व है जो आप विधि 5 में ले जाते हैं।

import requests
from urllib.parse import urljoin

HEADERS = {"User-Agent": "Mozilla/5.0 (sitemap-discovery)"}

def sitemaps_from_robots(base_url):
    """robots.txt में घोषित हर Sitemap: निर्देश को निकालें।"""
    resp = requests.get(urljoin(base_url, "/robots.txt"), headers=HEADERS, timeout=30)
    resp.raise_for_status()
    sitemaps = []
    for line in resp.text.splitlines():
        if line.lower().startswith("sitemap:"):
            sitemaps.append(line.split(":", 1)[1].strip())
    return sitemaps

if __name__ == "__main__":
    for sm in sitemaps_from_robots("https://example.com"):
        print("घोषित साइटमैप:", sm)

एक साइट का robots.txt अक्सर एक या एक से अधिक Sitemap: पंक्तियों की घोषणा करता है — जैसे Sitemap: https://example.com/sitemap.xml। उन श्रेणियों को सीधे विधि 2 से walk_sitemap में फीड करें और आपके पास प्रकाशक का पूर्ण घोषित URL सेट होगा बिना पथ का अनुमान लगाए।

संयुक्त पैटर्न स्थिर खोज का मूल है: साइटमैप(s) और अनुपालना पथों को खोजने के लिए robots.txt पढ़ें, फिर हर घोषित साइटमैप पर चलें। जो भी ये दोनों लौटाते हैं वो आपकी प्राधिकारित प्रारंभिक सूची है। इसके बाद सब कुछ उन पृष्ठों को खोजने के बारे में है जो वे छोड़ देते हैं।

अपनी API कुंजी मुफ्त योजना पर प्राप्त करें: app.scrapeless.com

विधि 4 — SEO क्रॉलर्स (कोई कोड विकल्प नहीं)

यदि आप Python को लिखना नहीं चाहते हैं, तो एक डेस्कटॉप या बादल SEO क्रॉलर खोज, लिंक-ग्राफ मानचित्रण, और रिपोर्टिंग एक उपकरण में करता है। सामान्य क्रॉलर्स — Screaming Frog SEO Spider, Sitebulb, और Ahrefs और Semrush में बनाए गए साइट-ऑडिट क्रॉलर्स — सभी वही मुख्य काम करते हैं: एक प्रारंभ URL सीड करें, आंतरिक लिंक को चौड़ाई-प्रथम का पालन करें, और हर URL के साथ एक तालिका उत्पन्न करें जो स्थिति कोड, शीर्षक, गहराई, और इनबाउंड लिंक संख्या के साथ खोजे गए हैं।

ये उपकरण उन समयों के लिए सही विकल्प हैं जब:

• आप कोड बनाए बिना एक दृश्य रिपोर्ट और CSV निर्यात चाहते हैं।
• आपको आपके लिए गणना किए गए मानक SEO कॉलम (स्थिति, कanonical, इंडेक्सेबल, रीडायरेक्ट श्रृंखलाएँ) की आवश्यकता है।
• साइट ज्यादातर सर्वर-जनरेटेड HTML है, जिसे डेस्कटॉप क्रॉलर्स मूल रूप से संभालते हैं।

उनकी सीमाएं जानने लायक हैं: मुफ्त स्तर URL गिनती को सीमित करते हैं (Screaming Frog का मुफ्त संस्करण 500 URLs पर रुक जाता है), JavaScript रेंडरिंग एक वैकल्पिक, धीमी विधि है जिसे हर स्तर सक्षम नहीं करता है, और बादल ऑडिट उपकरण परियोजना के आकार के अनुसार मूल्यांकन करते हैं। छोटे साइट के एक बार के ऑडिट के लिए ये बेहतरीन हैं; किसी अन्य सिस्टम को फीड करने वाले एक दोहराए जाने योग्य पाइपलाइन के लिए, नीचे के प्रोग्रामेटिक तरीके आपको रिपोर्ट के बजाय डेटा के रूप में URLs देते हैं। अगली दो विधियाँ उसी प्रोग्रामेटिक मार्ग की हैं।

विधि 5 — एक Python BFS आंतरिक-लिंक क्रॉलर

जब साइटमैप बासी या अनुपस्थित है, तो आप पृष्ठों की खोज उसी तरह करते हैं जैसे एक सर्च इंजन: होम पृष्ठ से शुरू करें, हर आंतरिक <a href> को पार्स करें, ऐसे लिंक को कतार में डालें जिन्हें आपने नहीं देखा है, और चौड़ाई-प्रथम दोहराएँ जब तक सीमा खाली न हो जाए या आप पृष्ठ की सीमा न छू लें। यह उस पृष्ठों को खोजने में मदद करता है जो कोई साइटमैप घोषित नहीं करता।

एक लिंक क्रॉलर में दो जिम्मेदारियां अनिवार्य हैं, और दोनों नीचे दिए गए कोड में शामिल हैं:

1. robots.txt की आज्ञा दें। किसी भी URL को अनुरोध करने से पहले can_fetch की जांच करें, और किसी भी चीज़ को छोड़ दें जिसे साइट अस्वीकार करती है। मानक-लाइब्रेरी urllib.robotparser नियमों को आपके लिए पढ़ती और मूल्यांकित करती है।
2. होस्ट पर रहें और डुप्लिकेट न बनाएं। केवल उन्हीं लिंक को कतार में डालें जिनका होस्ट प्रारंभिक होस्ट से मेल खाता है, URL के हिस्सों को हटाकर ताकि /page और /page#section एक बार गिने जाएँ, और एक seen सेट बनाएँ ताकि लिंक ग्राफ में चक्र हमेशा के लिए न जुड़े रहें।

import requests
from collections import deque
from html.parser import HTMLParser
from urllib.parse import urljoin, urldefrag, urlparse
from urllib.robotparser import RobotFileParser

HEADERS = {"User-Agent": "Mozilla/5.0 (link-discovery)"}

class LinkParser(HTMLParser):
    """एक पृष्ठ में <a> टैग से हर href इकट्ठा करें।"""
    def __init__(self):
        super().__init__()
        self.links = []
    def handle_starttag(self, tag, attrs):
        if tag == "a":
            for key, value in attrs:
                if key == "href" and value:
                    self.links.append(value)

def load_robots(base_url):
    rp = RobotFileParser()
    rp.set_url(urljoin(base_url, "/robots.txt"))
```python
rp.read()           # अस्वीकार नियमों और किसी भी क्रॉल-डिले को पार्स करता है
    return rp

def crawl(start_url, max_pages=200, user_agent="*"):
    """robots.txt का सम्मान करते हुए आंतरिक लिंक का चौड़ाई-प्रथम चलना।"""
    host = urlparse(start_url).netloc
    robots = load_robots(start_url)

    seen = {start_url}
    queue = deque([start_url])
    found, skipped = set(), []

    while queue and len(found) < max_pages:
        url = queue.popleft()

        # अनुपालन गेट: कभी भी उस पथ को न लाएं जो साइट अस्वीकार करती है।
        if not robots.can_fetch(user_agent, url):
            skipped.append(url)
            continue

        try:
            resp = requests.get(url, headers=HEADERS, timeout=30)
            resp.raise_for_status()
        except requests.RequestException:
            # एक बुरा URL बैंड से बाहर रिकॉर्ड किया जाता है, इसे इनलाइन नहीं खोजा जाता है।
            continue
        if "text/html" not in resp.headers.get("Content-Type", ""):
            continue

        found.add(url)

        parser = LinkParser()
        parser.feed(resp.text)
        for href in parser.links:
            absolute = urldefrag(urljoin(url, href))[0]   # समाधान + #fragment को छोड़ें
            if urlparse(absolute).netloc == host and absolute not in seen:
                seen.add(absolute)
                queue.append(absolute)

    return found, skipped

if __name__ == "__main__":
    pages, disallowed = crawl("https://example.com/", max_pages=200)
    print(f"पाए गए {len(pages):,} पृष्ठ; robots.txt द्वारा अस्वीकार किए गए {len(disallowed)} को छोड़ दिया गया।")

इस क्रॉलर का एक सक्रिय उपयोग एक स्थिर डेमो कैटलॉग के खिलाफ 40 पृष्ठों की खोज करता है, सिमा को 40 पर सेट किया गया है और शून्य URL छोड़े गए हैं, क्योंकि उस साइट का robots.txt कुछ भी अस्वीकार नहीं करता है। एक ऐसी साइट पर इंगित करते हुए जिसका robots.txt एक पथ को अस्वीकार करता है, वही क्रॉलर सही तरीके से अस्वीकार किए गए URL को अस्वीकार कर देता है और इसे skipped सूची में रिकॉर्ड करता है, बजाय इसके कि इसे लाया जाए - हर URL पर अनुपालन लागू होता है, न कि किसी सोच के बाद।

यह पहले के तरीकों के साथ कैसे मिलकर काम करता है:

• क्रॉलर वह सब खोजता है जो साइटमैप छोड़ता है; साइटमैप वह सब खोजता है जो क्रॉलर लिंक द्वारा नहीं पहुंच सकता। दोनों चलाएं और सबसे पूर्ण सूची के लिए संघ लें।
• असफलता बैंड से बाहर रहती है। एक URL जो त्रुटि उत्पन्न करता है, इसे इस पास से हटा दिया जाता है और क्रॉल आगे बढ़ता है - एक बुरा पृष्ठ पूरी यात्रा को कभी भी रोकता नहीं है। गिराए गए URL को समीक्षा के लिए अलग से इकट्ठा करें।
• विनम्रता के लिए समवर्तीता को सीमित करें। ऊपर दिए गए एकल-थ्रेडेड क्रॉलर पहले से ही नरम है। यदि आप समानांतर करते हैं, तो इसे प्रति होस्ट 3 से अधिक श्रमिकों तक सीमित रखें, और किसी भी Crawl-delay का सम्मान करें जो robots.txt घोषित करता है।
• क्रॉलर केवल HTML है। लोड के बाद JavaScript द्वारा पेंट किए गए लिंक requests के लिए अदृश्य हैं। यही वह अंतर है जिसे विधि 6 बंद करता है।

विधि 6 - जावास्क्रिप्ट-भारी पृष्ठों को Scrapeless Scraping Browser के साथ प्रदर्शित करें

requests-आधारित क्रॉलर जो भी बाइट्स सर्वर भेजता है उसे पढ़ता है। एक एकल-पृष्ठ ऐप, एक अनंत-सcroll कैटलॉग, या एक React/Vue/Next.js नेविगेशन के लिए, वे बाइट्स एक ऐप शेल हैं - <div id="root"></div> प्लस एक स्क्रिप्ट टैग - और आंतरिक लिंक क्लाइंट-साइड तब चित्रित होते हैं जब बंडल चलता है। साधारण HTTP उन्हें नहीं देख सकता; एक वास्तविक ब्राउज़र कर सकता है।

Scrapeless Scraping Browser पृष्ठ को एक क्लाउड ब्राउज़र में प्रस्तुत करता है और इसे क्रोम देव टूल्स प्रोटोकॉल के माध्यम से उजागर करता है। आप Playwright के साथ एक वेबसॉक्ट एंडपॉइंट के माध्यम से कनेक्ट करते हैं, गृहपृष्ठ को गर्म करते हैं ताकि सत्र कुकीज़ ले जाए, लक्ष्य पर नेविगेट करते हैं, फिर हाइड्रेटेड DOM से एंकर इकट्ठा करते हैं - विधि 5 में लिंक-विश्लेषण चरण का प्रदर्शित-पृष्ठ समकक्ष। यूएस निकासी सत्र पर पिन की गई है ताकि भू-नियंत्रित साइटें अपनी मानक संरचना प्रदान करें।

कनेक्शन एकल वेबसॉक परीक्षण URL है जो आपके API कुंजी से बनाया गया है। यह कनेक्शन आकार है:

import os
from urllib.parse import urlencode
from playwright.sync_api import sync_playwright

def scraping_browser_url(proxy_country="US", session_ttl=240):
    params = urlencode({
        "token": os.environ["SCRAPELESS_API_KEY"],
        "sessionTTL": session_ttl,
        "proxyCountry": proxy_country,
    })
    return f"wss://browser.scrapeless.com/api/v2/browser?{params}"

एंडपॉइंट हाथ में लेकर, लक्ष्य को रेंडर करें और इसके आंतरिक लिंक लें:

from urllib.parse import urljoin, urldefrag, urlparse

def discover_rendered_links(start_url, proxy_country="US"):
    """क्लाउड ब्राउज़र में एक JS-भारी पृष्ठ प्रस्तुत करें और समान-होस्ट लिंक एकत्र करें।"""
    host = urlparse(start_url).netloc
    homepage = f"{urlparse(start_url).scheme}://{host}/"

    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(scraping_browser_url(proxy_country))
        context = browser.contexts[0] if browser.contexts else browser.new_context()
        page = context.pages[0] if context.pages else context.new_page()

        # सबसे पहले गृहपृष्ठ को गर्म करें ताकि सत्र कुकीज़ ले जाए, फिर लक्ष्य पर जाएं।
        page.goto(homepage, wait_until="domcontentloaded", timeout=60_000)
        page.goto(start_url, wait_until="networkidle", timeout=60_000)

हाइड्रेटेड DOM से hrefs पढ़ें, जब क्लाइंट-साइड रेंडरिंग चल चुकी हो।

    hrefs = page.eval_on_selector_all(
        "a[href]", "els => els.map(e => e.getAttribute('href'))"
    )
    browser.close()

links = set()
for href in hrefs:
    if not href:
        continue
    absolute = urldefrag(urljoin(start_url, href))[0]
    if urlparse(absolute).netloc == host:
        links.add(absolute)
return links

if name == "main":
found = discover_rendered_links("https://example.com/app/catalog")
print(f"रेंडर के बाद {len(found):,} क्लाइंट-साइड लिंक खोजे गए")
for u in sorted(found)[:10]:
print(" ", u)

इससे इसे विश्वसनीय बनाने वाला पैटर्न:

- **होमपेज को सक्रिय करें, फिर नेविगेट करें।** पहले `goto` से `/` सत्र को कुकीज़ उठाने और साइट के पहले लोड की जांचों को पास करने की अनुमति मिलती है; दूसरा `goto` उस पृष्ठ पर पहुंचता है जिसे आप वास्तव में सूचीबद्ध करना चाहते हैं। ठंडे सत्र पर सीधे गहरे URL पर जाना चुनौती को आकर्षित करने की अधिक संभावना है।
- **लक्ष्य पर `wait_until="networkidle"`** क्लाइंट-साइड राउटर को DOM पढ़ने से पहले अपने लिंक माउंट करने का समय देता है। अनंत स्क्रॉल पृष्ठों के लिए, लिंक की संख्या बढ़ने तक लूप में नीचे स्क्रॉल करें (`page.mouse.wheel`) और फिर संग्रह करें।
- **रेंडरिंग Scrapeless के क्लाउड में चलती है,** आपके मशीन पर नहीं। स्थानीय `playwright install chromium` केवल CDP क्लाइंट है जो `wss://browser.scrapeless.com/...` अंत बिंदु से संवाद करता है।
- **परिणाम को यूनियन में वापस डालें।** रेंडर किए गए लिंक साइटमैप सेट और स्टेटिक-क्रॉल सेट में शामिल होते हैं; अंतिम सूची के लिए सामान्यीकृत URL द्वारा संयुक्त संग्रह को डू-डुप्लिकेट करें।

एक पूर्ण क्रॉलर में इसे वायर्ड करने के लिए, मेथड 5 में `requests.get` बॉडी को उन होस्टों पर `discover_rendered_links` के लिए बदलें जिन्हें आप जानते हैं कि वे जावास्क्रिप्ट-भारी हैं, और सर्वर-रेंडर किए गए बहुमत के लिए सस्ते `requests` पथ को बनाए रखें। वह HTTP-प्रथम, ब्राउज़र- दूसरे विभाजन केवल उन पृष्ठों तक क्लाउड-ब्राउज़र उपयोग को बनाए रखता है जिन्हें वास्तव में इसकी आवश्यकता है।

---

## आपको क्या मिलता है

हर विधि एक सेट के पूर्ण URLs का उत्सर्जन करती है; अंतिम सूची सभी के बीच डुप्लिकेट-हीन संघ है। एक होस्ट के लिए एक संयुक्त रिकॉर्ड ऐसा लगता है:

```json
// स्कीमा चार प्रोग्रामात्मक विधियों के संघ को दर्शाता है।
// गिनती केवल उदाहरणीय नमूने हैं, किसी साइट का आज का ठोस स्नैपशॉट नहीं।
{
  "host": "example.com",
  "discovered_at_methods": ["sitemap", "robots", "bfs_crawl", "rendered"],
  "counts": {
    "from_sitemap": 226,
    "from_bfs_crawl": 40,
    "from_rendered": 18,
    "union_unique": 248
  },
  "sample_urls": [
    "https://example.com/",
    "https://example.com/blog",
    "https://example.com/blog/how-to-scrape-bbb-business-listings",
    "https://example.com/app/catalog?page=2"
  ],
  "skipped_by_robots": [
    "https://example.com/private/"
  ]
}

पूर्ण-साइट URL की खोज के बारे में कुछ ईमानदार अवलोकन, जो बड़े पैमाने पर चलाने से पहले जानने लायक हैं:

• संघ किसी एकल स्रोत से बेहतर है। साइटमैप वह बताता है जो प्रकाशक ने पंजीकृत किया; BFS क्रॉल लिंक किए गए अनाथों को खोजता है; रेंडर्ड पास क्लाइंट-साइड लिंक खोजता है। कवरेज सभी तीनों का संघ है, जिसमें निषिद्ध पथ घटाए जाते हैं।
• मानकीकृत URLs पर डुप्लिकेट निकालें। अंशों को हटा दें, तय करें कि ट्रेलिंग स्लैश और ?utm_* क्वेरी पैरामीटर आपके उपयोग के मामले के लिए महत्वपूर्ण हैं या नहीं, और गिनने से पहले सामान्यीकृत करें — अन्यथा /page और /page/ कुल कोinflate कर सकते हैं।
• साइटमैप सामग्री में पीछे रह जाते हैं। एक पृष्ठ जो अंतिम साइटमैप निर्माण के बाद प्रकाशित होता है, केवल क्रॉल स्तरों में दिखाई देता है। यदि एक पूर्ण सूची का महत्व है, तो हमेशा साइटमैप पढ़ने के साथ-साथ क्रॉल चलाएं।
• क्लाइंट-साइड लिंक HTTP के लिए अदृश्य हैं। यदि ज्ञात-बड़े साइट का requests क्रॉल केवल कुछ URLs लौटाता है, तो नेविगेशन लगभग निश्चित रूप से क्लाइंट-साइड में प्रस्तुत किया गया है — उस होस्ट को मेथड 6 में बढ़ाएं।
• अंत तक निषिद्ध सूची का सम्मान करें। skipped_by_robots एरे एक TODO सूची नहीं है। वे पथ सूची में नहीं रहते।

निष्कर्ष: एक पूर्ण URL सूची बनाएं

हर पृष्ठ ढूंढना चार प्रोग्रामेटिक चालों तक सीमित हो जाता है जो एक मैन्युअल जांच के शीर्ष पर रखी जाती हैं: site: के साथ आकार का अनुमान लगाएं, साइटमैप स्थान और निषिद्ध पथों के लिए robots.txt पढ़ें, घोषित URLs के लिए साइटमैप पेड़ पर चलें, अनाथों के लिए आंतरिक लिंक ग्राफ को BFS-क्रॉल करें, और क्लाइंट-साइड लिंक के लिए क्लाउड ब्राउज़र में जावास्क्रिप्ट-भारी होस्ट को रेंडर करें। संघ लें, सामान्यीकृत URLs पर डुप्लिकेट निकालें, और यही सूची है।
प्रॉक्सी परत के लिए जो प्रस्तुत स्तर को रूट करती है, देखें SSL प्रॉक्सी क्या है?। स्क्रेपिंग ब्राउज़र उत्पाद पृष्ठ और मूल्य निर्धारण पृष्ठ क्लाउड-ब्राउज़र स्तर को कवर करते हैं; पूर्ण एसडीके संदर्भ docs.scrapeless.com पर है। प्रस्तुत स्तर पर यूएस एग्रेस को पिन करें, लक्षित पृष्ठ से पहले होमपृष्ठ को गर्म करें, प्रत्येक यूआरएल पर robots.txt का सम्मान करें, और अंतिम सूची को प्रत्येक तरीके का संघ मानें।

क्या आप अपनी एआई-संचालित डेटा पाइपलाइन बनाने के लिए तैयार हैं?

हमारे समुदाय में शामिल हों ताकि एक मुफ्त योजना का दावा कर सकें और URL-खोज और क्रॉलिंग पाइपलाइनों का निर्माण करने वाले डेवलपर्स के साथ जुड़ सकें: Discord · Telegram।

app.scrapeless.com पर मुफ्त स्क्रेपिंग ब्राउज़र रनटाइम के लिए साइन अप करें और ऊपर दिए गए पैटर्नों को उन साइटों, साइटमैप और क्षेत्रों के लिए अनुकूलित करें जिनकी पाइपलाइन को आवश्यकता है।

सामान्य प्रश्न

प्रश्न: क्या सभी पृष्ठों को खोजने के लिए किसी वेबसाइट को क्रॉल करना कानूनी है?

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

प्रश्न: साइटमैप या क्रॉल - कौन पूरी सूची देता है?

कोई भी अकेले नहीं। एक साइटमैप प्रकाशक का घोषित बयान है और अक्सर पुराना या आंशिक होता है; एक क्रॉल लिंक किए गए ग्राफ़ को खोजता है लेकिन ऐसे पृष्ठों को छोड़ देता है जिनका कोई पृष्ठ लिंक नहीं करता। पूर्ण इन्वेंट्री साइटमैप वॉक (पद्धति 2) और बीएफएस क्रॉल (पद्धति 5) का संघ है, जिसमें ग्राहक-पक्ष लिंक के लिए प्रस्तुत स्तर (पद्धति 6) जोड़ा गया है।

प्रश्न: मेरा क्रॉलर एक बड़े साइट पर केवल कुछ पृष्ठों को क्यों खोजता है?

साइट लगभग निश्चित रूप से अपने नेविगेशन को ग्राहक-पक्ष पर प्रस्तुत करती है। एक साधारण requests फ़ेच ऐप शेल को वापस करता है इससे पहले कि जावास्क्रिप्ट चले, इसलिए अनुसरण करने के लिए कोई लिंक नहीं होते। उन होस्टों को स्क्रेपलेस स्क्रेपिंग ब्राउज़र (पद्धति 6) के साथ प्रस्तुत करें और हाइड्रेटेड डोम से एंकर इकट्ठा करें।

प्रश्न: मुझे URL खोज के लिए प्रॉक्सी की आवश्यकता है?

एकल-होस्ट साइटमैप पढ़ने और एक विनम्र स्थैतिक क्रॉल के लिए, अक्सर नहीं। एक प्रॉक्सी तब अपना स्थान अर्जित करती है जब साइट सामग्री को जियो-गेट करती है (आपको अमेरिकी संरचना देखने के लिए यूएस एग्रेस की आवश्यकता होती है), जब आपका आईपी रेट-सीमित है, या जब प्रस्तुत स्तर को जैविक ट्रैफ़िक से मेल खाने के लिए आवासीय एग्रेस की आवश्यकता होती है। पद्धति 6 में स्क्रेपलेस कनेक्शन proxy_country="US" के साथ एग्रेस को पिन करता है।

प्रश्न: जब एक पृष्ठ एक एक्सेस चैलेंज प्रदान करता है, तो मुझे साफ़ प्रस्तुत कैसे मिलता है?

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

प्रश्न: जब साइट अपना एचटीएमएल या लिंक संरचना बदलती है, तो क्या होता है?

स्थैतिक क्रॉलर सामान्य <a href> तत्व पर कुंजी करता है, इसलिए मार्कअप परिवर्तनों से इसे तोड़ना दुर्लभ होता है। यदि आपने प्रस्तुत स्तर के चयनकर्ता को एक विशेष कंटेनर तक तंग किया है, तो जब मार्कअप बदलता है तो इसे फिर से जांचें और यदि साइट अपनी नेविगेशन को पुनर्गठित करती है तो इसे वापस a[href] तक चौड़ा करें।

प्रश्न: मैं क्रॉल करते समय साइट को हिट करने से कैसे बचूं?

पद्धति 5 में एकल-थ्रेडेड क्रॉलर पहले से ही सौम्य है। यदि आप समानांतर करते हैं, तो प्रति होस्ट 3 कार्यकर्ताओं से अधिक संप्रक्ति बनाए रखें, robots.txt में किसी भी Crawl-delay निर्देश का सम्मान करें, और कभी भी किसी ऐसे पथ को कतारबद्ध न करें जिसे निषेध नियम कवर करते हैं।

प्रश्न: मैं अंतिम यूआरएल सेट से डुप्लिकेट कैसे हटाऊं?

गिनने से पहले सामान्य करें: #fragments को स्ट्रिप करें, तय करें कि एक ट्रेलिंग स्लैश और ट्रैकिंग क्वेरी पैरामीटर (?utm_*) आपके उपयोग के मामले के लिए महत्वपूर्ण हैं या नहीं, और सामान्यीकृत रूप पर कुंजी के साथ set में यूआरएल स्टोर करें। प्रत्येक विधि पहले से ही एक set लौटाती है; सभी का संघ लें और डुप्लिकेट गिर जाएंगे।

प्रश्न: क्या मैं एआई एजेंट या किसी भी एसडीके के बिना यूआरएल खोज सकता हूं?

हां। विधियां 1-5 केवल पायथन मानक पुस्तकालय और requests का उपयोग करती हैं। विधि 6 Playwright को स्क्रेपलेस स्क्रेपिंग ब्राउज़र एंडपॉइंट से सीडीपी पर जोड़ती है - कोई एजेंट ढाँचा आवश्यक नहीं है, सिर्फ आपके एपीआई कुंजी से निर्मित वेब सॉकेट यूआरएल।