वेब स्क्रैपर कैसे बनाएं: एक प्रारंभ से पायथन गाइड

TL;DR:

• एक वेब स्क्रैपर तीन काम करता है: एक पृष्ठ लाना, HTML से फ़ील्ड निकालना, अगली पृष्ठ पर दोहराना। जब ये तीन कदम सही हो जाते हैं, तो आप जो भी स्क्रैपर बनाते हैं वह उसी लूप का एक रूपांतरण होता है।
• requests और BeautifulSoup स्टैटिक वेब को 30 लाइनों से भी कम में संभालते हैं। अभ्यास साइट books.toscrape.com पर, एक लूप सभी 50 लिस्टिंग पृष्ठों पर चलता है और 1,000 संरचित पुस्तक रिकॉर्ड लौटाता है।
• पृष्ठ नंबर बस "अगला" लिंक फॉलो करना है जब तक यह न दिखे। आप प्रत्येक पृष्ठ पर अगले पृष्ठ के एंकर को पढ़ते हैं, इसे एक पूर्ण URL में हल करते हैं, और तब तक चलते रहते हैं जब तक लिंक गायब न हो जाए।
• सादा HTTP जावा स्क्रिप्ट द्वारा रेंडर की गई सामग्री को नहीं देख सकता। अभ्यास पृष्ठ quotes.toscrape.com/js/ requests पर शून्य उद्धरण तत्व लौटाता है, क्योंकि मार्कअप क्लाइंट-साइड पर पृष्ठ लोड होने के बाद पेंट होता है।
• Scrapeless Scraping Browser उन पृष्ठों को क्लाउड-साइड रेंडर करता है और पेंटेड DOM वापस करता है। वही जावा स्क्रिप्ट पृष्ठ क्लाउड ब्राउज़र द्वारा कार्यान्वित होने पर 10 उद्धरण तत्व लौटाता है, इसलिए आपका मौजूदा BeautifulSoup पार्सिंग बिना बदलाव के काम करता है।
• शुरू करने के लिए स्वतंत्र। नए Scrapeless खातों में मुफ्त Scraping Browser रनटाइम शामिल है - app.scrapeless.com पर साइन अप करें।

परिचय: एक असली स्क्रैपर बनाएं, फिर उन पृष्ठों को संभालें जो लड़ते हैं

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

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

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

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

• उत्पाद कैटलॉग इकट्ठा करें। एक पृष्ठित सूची पर चलें और शीर्षक, मूल्य, और स्टॉक स्थिति को CSV या JSON फ़ाइल में खींचें।
• समय के साथ कीमतों पर नज़र रखें। एक शेड्यूल पर उसी स्क्रैपर को फिर से चलाएँ और संख्याओं का अंतर करें ताकि कीमतों में गिरावट देख सकें।
• विश्लेषण या AI के लिए डेटासेट बनाएं। असंरचित HTML के पृष्ठों को साफ पंक्तियों में बदलें जिन्हें आपका नोटबुक या मॉडल पढ़ सके।
• उपलब्धता की निगरानी करें। कई पृष्ठों पर जांचें कि क्या आइटम स्टॉक में हैं बिना हाथ से क्लिक किए।
• शोध पाइपलाइन को फीड करें। उद्धरण, लेख, या समीक्षाएँ एक संरचित स्टोर में खींचें ताकि नीचे की प्रक्रिया के लिए।
• जावा स्क्रिप्ट द्वारा रेंडर की गई पृष्ठों तक पहुंचें। उन पृष्ठों को क्लाउड ब्राउज़र पर बढ़ाएं जो सादा HTTP पर शून्य खोल लौटाते हैं और वही पार्सिंग कोड रखें।

Scrapeless Scraping Browser क्यों

Scrapeless Scraping Browser एक कस्टमाइज़ेबल, एंटी-डिटेक्शन क्लाउड ब्राउज़र है जो वेब क्रॉलर्स और AI एजेंटों के लिए डिज़ाइन किया गया है। एक स्क्रैपर के लिए विशेष रूप से, यह एक ऐसी समस्या को हल करता है जिसे requests नहीं कर सकता — पृष्ठ को चलाना — और लाएगा:

• क्लाउड-साइड जावास्क्रिप्ट रेंडरिंग। पृष्ठ जो अपनी सामग्री को क्लाइंट-साइड के रूप में पेंट करते हैं, एक पूर्ण रूप से रेंडर की गई DOM लौटाते हैं, इसलिए BeautifulSoup परिणाम को उस तरह से पार्स करता है जैसे वह एक स्थिर पृष्ठ होता।
• 195+ देशों में आवासीय प्रॉक्सी। एक देश कोड के साथ निकासी भौगोलिकता पिन करें ताकि एक पृष्ठ उसी सामग्री को लौटाए जो एक स्थानीय आगंतुक देखेगा।
• एंटी-डिटेक्शन फ़िंगरप्रिंटिंग। क्लाउड ब्राउज़र एक सुसंगत, मानव-समान ब्राउज़र सतह पेश करता है बजाय एक नंगे HTTP क्लाइंट हस्ताक्षर के।
• पूरे चीज़ के लिए एक API कुंजी। पायथन SDK एक browser_ws_endpoint बनाता है जिसे आप Playwright के साथ कनेक्ट करते हैं; वही कुंजी रनटाइम को कवर करती है।

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

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

• Python 3.10 या नया
• स्थिर स्तर के लिए requests और beautifulsoup4
• जावा स्क्रिप्ट द्वारा रेंडर की गई परत के लिए scrapeless SDK और playwright
• एक Scrapeless खाता और API कुंजी - app.scrapeless.com पर साइन अप करें
• टर्मिनल के साथ मूल परिचय

इंस्टॉल करें

पहले दो स्थिर-स्तरीय पुस्तकालयों को स्थापित करें:

pip install requests beautifulsoup4

requests HTTP के माध्यम से पृष्ठों को लाता है; beautifulsoup4 लौटाए गए HTML को - HTML मानक द्वारा परिभाषित मार्कअप - को एक पेड़ में जोड़ता है जिसे आप CSS चयनकर्ताओं के साथ क्वेरी कर सकते हैं। यह जोड़ा चरण 1 से 4 तक हर स्थिर पृष्ठ के लिए काफी है। चरण 5 में JavaScript-निर्मित स्तर में दो और पैकेज शामिल हैं, जो वहां स्थापित किए जाते हैं।

चरण 1 - एक पृष्ठ प्राप्त करें और पुष्टि करें कि आपको वास्तविक HTML मिला है

एक स्क्रैपर एक अनुरोध के साथ शुरू होता है। लक्ष्य URL पर GET भेजें HTTP अर्थविज्ञान का पालन करते हुए, स्थिति कोड की जांच करें, और पुष्टि करें कि HTML वास्तव में उन रिकॉर्डों को शामिल करता है जिनकी आप अपेक्षा करते हैं इससे पहले कि आप एक सिंगल चयनकर्ता लिखें।

import requests
from bs4 import BeautifulSoup

url = "http://books.toscrape.com/"
resp = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (tutorial-scraper)"}, timeout=30)
print("स्थिति:", resp.status_code, "बाइट्स:", len(resp.text))

soup = BeautifulSoup(resp.text, "html.parser")
books = soup.select("article.product_pod")
print("इस पृष्ठ पर पुस्तक कार्ड:", len(books))

books.toscrape.com के खिलाफ यह स्थिति: 200 और इस पृष्ठ पर पुस्तक कार्ड: 20 प्रिंट करता है। User-Agent हेडर आपके क्लाइंट की पहचान करता है; कई सर्वर बिना भेजे गए अनुरोधों को अस्वीकार करते हैं। यदि एक वास्तविक साइट पर गिनती शून्य के रूप में वापस आती है, तो यह प्रारंभिक संकेत है कि पृष्ठ JavaScript-निर्मित है - स्थिति जिसे चरण 5 संभालता है।

चरण 2 - रिकॉर्ड खोजें, फिर इसके फ़ील्ड निकालें

पहले दोहराए जाने वाले कंटेनर को चुनें, फिर इसके अंदर के फ़ील्ड पढ़ें। एक स्थिर हुक - एक अर्थपूर्ण टैग, एक data-* एट्रिब्यूट, या एक वर्ग जो डेटा का वर्णन करता है - को पसंद करें, इसके बजाय एक हैश की गई कक्षा जो अगले डिज़ाइन पर टूट जाती है। books.toscrape.com पर प्रत्येक पुस्तक एक article.product_pod है, और फ़ील्ड अनुमानित बाल चयनकर्ताओं से लटके होते हैं।

import requests
from bs4 import BeautifulSoup

resp = requests.get(
    "http://books.toscrape.com/",
    headers={"User-Agent": "Mozilla/5.0 (tutorial-scraper)"},
    timeout=30,
)
resp.encoding = resp.apparent_encoding  # कैटलॉग £ का उपयोग करता है; अनुरोधों को इसे पहचानने दें
soup = BeautifulSoup(resp.text, "html.parser")

pod = soup.select_one("article.product_pod")
title = pod.h3.a["title"]
price = pod.select_one("p.price_color").get_text(strip=True)
in_stock = "In stock" in pod.select_one("p.instock.availability").get_text()
print(title, "|", price, "|", "स्टॉक में" if in_stock else "स्टॉक से बाहर")

यह A Light in the Attic | £51.77 | स्टॉक में प्रिंट करता है। resp.encoding = resp.apparent_encoding लाइन महत्वपूर्ण है: इसके बिना पाउंड का चिन्ह मोज़ीबेक के रूप में डिकोड होता है, क्योंकि उत्तर हेडर और दस्तावेज़ की वास्तविक एनकोडिंग असहमत होती है। उस तत्व से फ़ील्ड पढ़ें जो इसे पहले ही रखता है - शीर्षक एंकर के title एट्रिब्यूट में रहता है, इसलिए एक चयनकर्ता दोनों खोज और निष्कर्षण करता है।

चरण 3 - "अगला" लिंक गायब होने तक पृष्ठांकन का पालन करें

एक सूची अक्सर एक पृष्ठ में नहीं आती है। विश्वसनीय पैटर्न यह है कि प्रत्येक पृष्ठ पर अगले पृष्ठ के लिंक को पढ़ें, इसे वर्तमान URL के खिलाफ हल करें, और तब तक लूप करें जब तक कोई अगला लिंक न बचे। अनुमान लगाने के लिए कोई पृष्ठ गिनती नहीं, बनाए रखने के लिए कोई हार्डकोडेड रेंज नहीं।

import requests
from urllib.parse import urljoin
from bs4 import BeautifulSoup

session = requests.Session()
session.headers.update({"User-Agent": "Mozilla/5.0 (tutorial-scraper)"})

records = []
url = "http://books.toscrape.com/catalogue/page-1.html"
pages = 0
while url:
    resp = session.get(url, timeout=30)
    resp.encoding = resp.apparent_encoding
    soup = BeautifulSoup(resp.text, "html.parser")
    for pod in soup.select("article.product_pod"):
        records.append({
            "title": pod.h3.a["title"],
            "price": pod.select_one("p.price_color").get_text(strip=True),
            "in_stock": "In stock" in pod.select_one("p.instock.availability").get_text(),
        })
    pages += 1
    next_link = soup.select_one("li.next > a")
    url = urljoin(url, next_link["href"]) if next_link else None

print("पृष्ठ क्रॉल किए गए:", pages, "| रिकॉर्ड एकत्र किए गए:", len(records))

books.toscrape.com पर यह सभी 50 सूची पृष्ठों को चलाता है और 1,000 रिकॉर्ड एकत्र करता है। एक requests.Session अनुरोधों के बीच अंतर्निहित कनेक्शन को पुनः उपयोग करता है, जो हर बार ताज़ा requests.get की तुलना में तेज़ होता है। urljoin सापेक्ष href (जैसे page-2.html) को एक निरपेक्ष URL में बदलता है ताकि अगला अनुरोध सही तरीके से हल हो सके।

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

चरण 4 - संरचित आउटपुट लिखें

स्क्रैप किया गया डेटा केवल तभी उपयोगी होता है जब इसे संरचित किया जाए। चरण 3 की records सूची पहले से ही एक संगठित शब्दकोशों की सूची है जिसमें स्थिर कुंजी हैं, इसलिए इसे CSV या JSON में लिखना कुछ पंक्तियों का काम है। अपने स्कीमा को पहले से तय करें - हर पंक्ति पर समान कुंजी - और अनुपस्थित फ़ील्ड एक None हो जाती हैं, कभी भी एक क्रैश नहीं।

import csv
import json

# records चरण 3 में बनाई गई dicts की सूची है।
with open("books.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "price", "in_stock"])
    writer.writeheader()
    writer.writerows(records)

with open("books.json", "w", encoding="utf-8") as f:
    json.dump(records, f, ensure_ascii=False, indent=2)

print("लिखा", len(records), "पंक्तियाँ books.csv और books.json में")

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

जहां सामान्य HTTP रुकता है: JavaScript-जनित पृष्ठ

उपरोक्त स्क्रैपर उस क्षण टूट जाता है जब एक साइट अपने सामग्री को JavaScript के साथ प्रस्तुत करती है। अभ्यास पृष्ठ quotes.toscrape.com/js/ ठीक इस पाठ के लिए बनाया गया है — उद्धरण एक स्क्रिप्ट द्वारा पृष्ठ के लोड होने के बाद इंजेक्ट किए जाते हैं, प्रारंभिक HTML में उपस्थित नहीं होते हैं।

import requests
from bs4 import BeautifulSoup

resp = requests.get("https://quotes.toscrape.com/js/",
                    headers={"User-Agent": "Mozilla/5.0"}, timeout=30)
soup = BeautifulSoup(resp.text, "html.parser")
print("बाइट्स:", len(resp.text), "| उद्धरण तत्व:", len(soup.select("div.quote")))

यह लौटाता है बाइट्स: 5806 और उद्धरण तत्व: 0। अनुरोध सफल हुआ — स्थिति 200, असली बाइट्स — लेकिन पर्स की गई पृष्ठ में कोई उद्धरण नहीं हैं, क्योंकि requests कभी भी उस JavaScript को निष्पादित नहीं करता जो उन्हें बनाता है। कोई चयनकर्ता समायोजन इसे ठीक नहीं करता; डेटा वास्तव में प्रतिक्रिया में नहीं है। पृष्ठ को एक ब्राउज़र द्वारा चलाना अनिवार्य है।

चरण 5 - Scrapeless स्क्रैपिंग ब्राउज़र के साथ पृष्ठ प्रस्तुत करें

हर पृष्ठ के लिए स्थानीय रूप से एक पूरा ब्राउज़र चलाना भारी होता है और जल्दी ही अवरोधित हो जाता है। साफ रास्ता एक क्लाउड ब्राउज़र है: Scrapeless एक सत्र तैयार करता है, पृष्ठ को अपनी ओर प्रस्तुत करता है, और समाप्त DOM को वापस लौटाता है — जिसे आप पहले से लिखी गई वही BeautifulSoup कोड के साथ पार्स करते हैं। दो अतिरिक्त पैकेज स्थापित करें, फिर Playwright के साथ Chrome DevTools प्रोटोकॉल के माध्यम से कनेक्ट करें।

pip install scrapeless playwright
playwright install chromium

playwright install chromium एक स्थानीय प्रोटोकॉल क्लाइंट एक बार डाउनलोड करता है; वास्तविक प्रस्तुतिकरण अभी भी Scrapeless के क्लाउड में चलता है। पहले अपना कुंजी निर्यात करें (export SCRAPELESS_API_KEY=your_api_token_here), फिर:

from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser
from playwright.sync_api import sync_playwright
from bs4 import BeautifulSoup

client = Scrapeless()  # पर्यावरण से SCRAPELESS_API_KEY पढ़ता है
session = client.browser.create(
    ICreateBrowser(proxy_country="US", session_ttl=180)
)

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(session.browser_ws_endpoint)
    ctx = browser.contexts[0] if browser.contexts else browser.new_context()
    page = ctx.pages[0] if ctx.pages else ctx.new_page()
    page.goto("https://quotes.toscrape.com/js/", wait_until="domcontentloaded", timeout=60_000)
    page.wait_for_timeout(4_000)  # क्लाइंट-साइड स्क्रिप्ट को उद्धरणों को पेंट करने दें
    html = page.content()
    browser.close()

soup = BeautifulSoup(html, "html.parser")
quotes = soup.select("div.quote")
print("प्रस्तुत बाइट्स:", len(html), "| उद्धरण तत्व:", len(quotes))
print(quotes[0].select_one("small.author").get_text(strip=True))

यह लौटाता है प्रस्तुत बाइट्स: 9246 और उद्धरण तत्व: 10, और प्रिंट करता है Albert Einstein — वही पृष्ठ जिसने आपको सामान्य HTTP पर शून्य दिया। session.browser_ws_endpoint एक wss://browser.scrapeless.com/... URL है; Playwright का connect_over_cdp इससे DevTools प्रोटोकॉल से बात करता है, इस प्रकार पृष्ठ क्लाउड में चलता है जबकि आपका कोड स्थानीय रूप से चलता है। wait_until="domcontentloaded" और एक संक्षिप्त निश्चित बसना स्क्रिप्ट-चालित पृष्ठ पर नेटवर्क निश्चल होने के लिए प्रतीक्षा करने से अधिक विश्वसनीय है। SDK और CLI सतह का दस्तावेजीकरण docs.scrapeless.com पर है।

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

एक बार जब क्लाउड ब्राउज़र प्रस्तुत HTML लौटाता है, तो पार्स स्थिर स्तर के समान होता है — समान चयनकर्ता, समान शब्दकोश आकार:

[
  {
    "text": "जो दुनिया हमने बनाई है, वह हमारे सोचने की एक प्रक्रिया है।",
    "author": "Albert Einstein",
    "tags": ["बदलाव", "गहरी-सोच", "सोचने", "दुनिया"]
  }
]
// स्कीमा सही ढंग से उस div.quote के पार्स का प्रतिबिंबित करता है। मान निदर्शक नमुने हैं।

प्रस्तुत पृष्ठों के बारे में कुछ ईमानदार अवलोकन:

• समय प्रबंधित करें पृष्ठों पर। उद्धरण केवल तब दिखाई देते हैं जब पृष्ठ का स्क्रिप्ट चलता है, इसलिए domcontentloaded के बाद का संक्षिप्त समय उन्हें प्रस्तुत करता है। यदि समय बहुत कम है, तो आप एक खाली पृष्ठ को पार्स कर सकते हैं।
• चुनौतियाँ अभी भी बनी रहती हैं। div.quote, span.text, और small.author इस सैंडबॉक्स का मार्कअप हैं; किसी वास्तविक साइट पर, जब पृष्ठ बदलता है तो चयनकर्ताओं को फिर से जांचें।
• अनुपस्थित फ़ील्ड सामान्य हैं। एक रिकॉर्ड में कोई टैग या कीमत गायब हो सकती है; हर फ़ील्ड को नल करने योग्य मानें और आपका लेखन साफ़ पंक्तियाँ बनाना जारी रखेगा।
• अपने निर्गम को पिन करें। proxy_country="US" तैयार सामग्री को एक अमेरिकी आगंतुक के साथ सुसंगत रखता है; उस क्षेत्र के लिए कोड स्विच करें जिसकी आपको आवश्यकता है।

निष्कर्ष: एक पृष्ठ से एक वास्तविक पाइपलाइन की ओर

एक कार्यशील स्क्रैपर चार चरणों में समापित होता है: पृष्ठ लाना, दोहराए जाने वाले रिकॉर्ड का पता लगाना, इसके फ़ील्ड निकालना, और पृष्ठांकन का पालन करना जब तक यह समाप्त नहीं हो जाता। यह स्थिर वेब को requests और BeautifulSoup के साथ कवर करता है। एकमात्र मामला जिसकी यह पहुँच नहीं बना पाता — पृष्ठ जो अपनी सामग्री को JavaScript के साथ बनाते हैं — साफ़ तरीके से Scrapeless Scraping Browser पर स्थानांतरित होता है, जो पृष्ठ को क्लाउड-साइड पर रेंडर करता है और उसी DOM को लौटा देता है जिसे आपका पार्सर पहले से समझता है।

यहां से इसे उसी तरीके से स्केल करें जिस तरह हर उत्पादन स्क्रैपर स्केल करता है: अपने चयनकर्ताओं को संकीर्ण रखें और जब मार्कअप स्थानांतरित हो, उन्हें फिर से जांचें, निर्गम भूगोल को पिन करें ताकि वह दर्शकों से मेल खाता हो जिनका पृष्ठ सेवा देता है, अनुपस्थित फ़ील्ड को नल मानें, और केवल उन पृष्ठों पर क्लाउड ब्राउज़र के लिए पहुँचें जिन्हें वास्तव में रेंडरिंग की आवश्यकता होती है। समान JavaScript में विभाजन के लिए, Cheerio और Puppeteer गाइड Node.js में स्थिर बनाम गतिशील निर्णय को समझाता है। जब आप इसे बड़े पैमाने पर चलाने के लिए तैयार हों, तो प्राइसिंग पेज पर रनटाइम विकल्पों की तुलना करें।

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

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

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

सर्व frequentlyasked_questions

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

प्रश्न: क्या मुझे स्क्रैपर बनाने के लिए एक प्रॉक्सी की आवश्यकता है?
किसी अनुमत साइट के खिलाफ कम मात्रा के स्क्रैपर के लिए, नहीं। उन साइटों के लिए जो आईपी द्वारा दर सीमा निर्धारित करते हैं या क्षेत्र के अनुसार सामग्री बदलते हैं, हां - आवासीय प्रॉक्सियों के माध्यम से राउट करें और देश को पिन करें ताकि पृष्ठ उसी सामग्री को लौटाए जिससे कोई स्थानीय आगंतुक देखता है। चरण 5 में स्क्रैपिंग ब्राउज़र स्तर में proxy_country सेटिंग के साथ प्रॉक्सी निर्गम शामिल है।

प्रश्न: मेरा स्क्रैपर खाली पृष्ठ क्यों लौटाता है?
लगभग हमेशा क्योंकि पृष्ठ अपनी सामग्री को प्रारंभिक प्रतिक्रिया के बाद JavaScript के साथ रेंडर करता है। साधारण requests सर्वर के बाइट्स को डाउनलोड करता है लेकिन पृष्ठ के स्क्रिप्ट को कभी नहीं चलाता, इसलिए आपको ब्राउज़र में जो डेटा दिखाई देता है वह प्रतिक्रिया में नहीं है। तत्वों की संख्या प्रिंट करके पुष्टि करें, जैसे "जहां साधारण HTTP रुकता है" अनुभाग में, फिर पृष्ठ को क्लाउड ब्राउज़र के साथ रेंडर करें।

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

प्रश्न: मेरे चयनकर्ताओं ने नवीनीकरण के बाद काम करना बंद कर दिया — अब क्या?
मार्कअप घूमता है। पृष्ठ की फिर से जांच करें, स्थिर हुक (सेमान्टिक टैग, data-* गुण, डेटा का वर्णन करने वाली कक्षाएं) को हैश किए गए CSS कक्षाओं के बजाय प्राथमिकता दें, और चयनकर्ताओं को अपडेट करें। उपलब्ध सबसे स्थायी हुक के खिलाफ निर्माण करना स्क्रैपर को सुधार के बीच लंबे समय तक जीवित रखने में मदद करता है।

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

प्रश्न: क्या मुझे सब कुछ के लिए एक ब्राउज़र का उपयोग करना होगा?
नहीं, और आपको ऐसा नहीं करना चाहिए। requests और BeautifulSoup के साथ स्थिर स्तर तेज़ और सस्ता है, इसलिए इसे हर उस पृष्ठ के लिए इस्तेमाल करें जो रेंडर किया गया HTML भेजता है। केवल उन्हीं पृष्ठों के लिए क्लाउड ब्राउज़र तक ले जाएँ जिन्हें वास्तव में JavaScript निष्पादन की आवश्यकता होती है।