Die meisten Daten im Internet liegen in unstrukturiertem HTML verstreut auf Seiten, die für menschliche Augen und nicht für Ihre Skripte gebaut wurden. Web Scraping ist die Art, wie man das in strukturierte Datensätze umwandelt, die man speichern, abfragen und analysieren kann, ohne manuell zu kopieren oder darauf zu warten, dass eine Website eine API ausliefert, die sie vielleicht nie bauen wird. Preisbeobachtung, Marktforschung, Lead-Listen und die Erfassung von Trainingsdaten beginnen alle auf dieselbe Weise: eine Seite abrufen, sie parsen und die gewünschten Felder speichern.
Dieser Leitfaden geht den vollständigen Python-Workflow von Anfang bis Ende durch. Sie richten das Toolkit ein, senden eine Anfrage, parsen HTML mit CSS-Selektoren, verarbeiten JavaScript-gerenderte Seiten, folgen der Paginierung, speichern die Ergebnisse als CSV oder JSON und befassen sich mit den Blockierungen, die in dem Moment auftauchen, in dem man skaliert. Jedes Snippet ist real und kopierbar, und der gesamte Walkthrough beschränkt sich auf öffentliche Daten auf einer Praxis-Site, die zum Lernen gebaut wurde.
Was Sie bauen werden
Einen kleinen, vollständigen Python-Scraper, der eine paginierte Liste von Bucheinträgen von einer öffentlichen Praxis-Site liest, einen sauberen Datensatz von jedem herausnimmt, jede Seite durchläuft, bis es keine mehr gibt, und alles auf die Festplatte schreibt. Dieselbe Form, abrufen dann parsen dann schleifen dann speichern, ist das Rückgrat fast jedes Scrapers, den Sie je schreiben werden.
- Titel. Der Produktname von jeder Eintragskarteikarte.
- Preis. Die angezeigte Preiszeichenkette, bereit zum Bereinigen zu einer Zahl.
- Verfügbarkeit. Ob der Artikel vorrätig ist.
- Bewertung. Die Sternebewertung, die jeder Karte beigefügt ist.
- URL. Der absolute Link zur Detailseite.
Wir zielen auf books.toscrape.com, eine Sandbox, die speziell für das Üben von Scraping gebaut wurde. Sie ist statisch, gut strukturiert und zulässig, sodass Sie sich auf die Technik konzentrieren können, ohne beim ersten Versuch gegen Blockierungen zu kämpfen.
Wie Web Scraping funktioniert
Ein Scraper ist nur ein HTTP-Client plus ein Parser. Der Client fordert eine URL an und der Server gibt HTML zurück; der Parser lädt dieses HTML in einen Baum, den man nach Tag, Klasse oder CSS-Selektor abfragen kann, und man kopiert die gewünschten Werte in eine Liste von Datensätzen. Suchmaschinen haben seit den frühen Crawlern von 1993 auf diese Weise funktioniert, und die Mechanik hat sich kaum verändert: URLs entdecken, jede abrufen, strukturierte Felder extrahieren und weitermachen.
Was sich geändert hat, ist das moderne Web. Viele Sites liefern jetzt eine fast leere HTML-Hülle und rendern den sichtbaren Inhalt im Browser mit JavaScript, und die meisten ernsthaften Ziele verteidigen sich gegen automatisierten Traffic. Diese zwei Realitäten, Client-seitiges Rendering und Bot-Abwehr, sind der Grund, warum ein "umfassender" Leitfaden nicht bei requests und BeautifulSoup aufhören kann. Wir beginnen mit dem einfachen Stack, weil er die Grundlagen lehrt, und zeigen dann, wo er bricht und was ihn ersetzt.
Das Python-Toolkit einrichten
Das Python-Scraping-Ökosystem ist tiefgründig, aber man braucht nur eine Handvoll Werkzeuge, um fast jeden Job zu erledigen. Hier ist das moderne Toolkit und wann jedes Teil seinen Platz verdient.
- requests sendet HTTP-Anfragen und gibt die Antwort zurück. Es ist der richtige Standard für statische Seiten.
- BeautifulSoup parst HTML in einen navigierbaren Baum und ist tolerant gegenüber dem unordentlichen Markup, das echte Seiten immer haben.
- lxml ist ein schnelles Parser-Backend, das BeautifulSoup verwenden kann, und es bringt volle XPath-Unterstützung mit, wenn man sie braucht.
- Selenium oder Playwright steuern einen echten Browser, sodass sie JavaScript rendern und mit einer Seite durch Klicken und Tippen interagieren können.
- Scrapy ist ein vollständiges Crawling-Framework mit eingebauter Nebenläufigkeit, Wiederholungen und Pipelines, für wenn ein Skript zu einem echten Projekt wächst.
Für einen umfassenderen Überblick über das Verfügbare, siehe die besten Python-Web-Scraping-Bibliotheken. Für dieses Tutorial mit einer sauberen virtuellen Umgebung und den zwei Bibliotheken beginnen, die die Kernarbeit erledigen.
python --version python -m venv scraper_env source scraper_env/bin/activate pip install requests beautifulsoup4 lxml
Unter Windows die Umgebung mit scraper_env\Scripts\activate statt der source-Zeile aktivieren. Python 3.8 oder höher wird benötigt; mit python --version prüfen und von python.org installieren, wenn es fehlt. Mit aktivierter Umgebung ist man bereit, die erste Anfrage zu senden.
Schritt 1: Eine Anfrage senden und die Antwort lesen
Jede Scrape beginnt mit einer einzigen HTTP-Anfrage. Einen GET an die URL senden, den Statuscode bestätigen, dass er 200 ist, bevor man sonst etwas tut, und das HTML der Seite liegt vor.
import requests url = "https://books.toscrape.com/catalogue/page-1.html" headers = {"User-Agent": "Mozilla/5.0 (scraper tutorial)"} response = requests.get(url, headers=headers, timeout=10) if response.status_code == 200: print(response.text[:500]) else: print(f"Request failed: {response.status_code}")
Zwei kleine Gewohnheiten zahlen sich sofort aus. Ein User-Agent-Header lässt die Anfrage wie einen Browser statt ein anonymes Skript aussehen, was viele Sites bevorzugen. Ein timeout verhindert, dass der Scraper ewig hängt, wenn ein Server stockt. Das ausführen und man sollte die ersten 500 Zeichen echten HTMLs im Terminal gedruckt sehen, was bestätigt, dass der Abruf funktioniert, bevor man einen einzigen Selektor schreibt.
Dieses bare requests.get funktioniert auf einer statischen Praxis-Seite, aber auf einem echten Ziel bricht es bei JavaScript und wird im großen Maßstab blockiert. Die Crawling API nimmt dieselbe URL, rendert die Seite in einem echten Browser hinter einer rotierenden Residential-IP und gibt fertiges HTML zurück, sodass der Parsing-Code in den nächsten Schritten identisch bleibt und man das Betreiben einer Headless-Browser-Flotte und eines Proxy-Pools selbst überspringt.
Schritt 2: HTML mit Selektoren parsen
Rohes HTML ist nur eine Zeichenkette. Um Elemente auszuwählen, lädt man es in BeautifulSoup, das das Markup in einen Baum umwandelt, den man nach Tag-Namen und CSS-Klasse abfragen kann. Die Seite im Browser öffnen, mit der rechten Maustaste auf eine Buchkarte klicken und Inspizieren wählen, um die Struktur zu lesen: Auf dieser Site sitzt jedes Buch in einem article.product_pod, mit dem Titel im h3 a-Titelattribut, dem Preis in p.price_color, Verfügbarkeit in p.instock und der Bewertung als Klasse auf p.star-rating kodiert.
from bs4 import BeautifulSoup soup = BeautifulSoup(response.text, "lxml") books = soup.select("article.product_pod") print(f"Found {len(books)} books on this page")
Das "lxml"-Argument weist BeautifulSoup an, mit dem schnellen lxml-Backend zu parsen, das man installiert hat; wenn man die Installation überspringt, stattdessen "html.parser" übergeben, das mit Python geliefert wird. Die select-Methode nimmt einen CSS-Selektor und gibt jede Übereinstimmung als Liste zurück, also gibt article.product_pod alle zwanzig Buchkarten auf der Seite. Wenn man find und find_all bevorzugt, erledigen sie dieselbe Aufgabe mit einem Methodenaufruf-Stil. Für eine tiefere Tour beider Stile, siehe wie man BeautifulSoup in Python verwendet, und für den Unterschied zwischen CSS-Selektoren und XPath, siehe Web Scraping mit XPath und CSS-Selektoren.
Schritt 3: Saubere Felder extrahieren
Jetzt die Daten aus jeder Karte herausziehen. Über die Elemente iterieren, den Wert aus jedem Kind lesen und ein ordentliches Dictionary pro Buch sammeln. Das Einwickeln der Selektoren in einen kleinen Helfer verhindert, dass ein fehlendes Feld den gesamten Durchlauf zum Absturz bringt.
from urllib.parse import urljoin BASE = "https://books.toscrape.com/catalogue/" def text_of(element, selector): el = element.select_one(selector) return el.get_text(strip=True) if el else None def parse_books(soup): rows = [] for card in soup.select("article.product_pod"): link = card.select_one("h3 a") rating = card.select_one("p.star-rating") rows.append({ "title": link["title"] if link else None, "price": text_of(card, "p.price_color"), "availability": text_of(card, "p.instock"), "rating": rating["class"][1] if rating else None, "url": urljoin(BASE, link["href"]) if link else None, }) return rows
Der text_of-Helfer fragt ein einzelnes Element ab und gibt None zurück, wenn es fehlt, anstatt bei einem .get_text()-Aufruf gegen nichts zu werfen. Titel und URL kommen aus Attributen statt aus Text, also liest man sie direkt vom <a>-Tag ab. Die Bewertung ist als zweite Klasse auf p.star-rating gespeichert (zum Beispiel class="star-rating Three"), also nimmt man den zweiten Klassennamen. urljoin wandelt das relative href in eine absolute URL um. parse_books(soup) aufrufen und man bekommt eine saubere Liste von Dictionaries, eines pro Buch.
Schritt 4: JavaScript-gerenderte Seiten verarbeiten
Die Praxis-Site ist statisch, was genau der Grund ist, warum sie ein gutes erstes Ziel ist. Viele echte Sites sind es nicht: Sie senden eine fast leere Hülle und bauen den Inhalt im Browser mit JavaScript. requests ruft nur diese initiale Hülle ab und führt niemals Skripte aus, sodass die Felder, die man im Browser gesehen hat, beim Parsen der Antwort einfach nicht vorhanden sind.
Der klassische Fix ist ein echter Browser. Playwright (oder Selenium) startet Chromium, lässt das JavaScript der Seite ausführen und übergibt dann das vollständig gerenderte HTML, das in denselben BeautifulSoup-Parser fließt, den man bereits geschrieben hat.
# pip install playwright && playwright install chromium from playwright.sync_api import sync_playwright def render(url): with sync_playwright() as p: browser = p.chromium.launch(headless=True) page = browser.new_page() page.goto(url, wait_until="networkidle") html = page.content() browser.close() return html soup = BeautifulSoup(render(url), "lxml")
Die Option wait_until="networkidle" hält, bis die Seite keine Netzwerkanfragen mehr stellt, was für Client-gerenderter Inhalt zum Erscheinen normalerweise ausreicht. Das funktioniert, aber ein Headless-Browser ist schwer: Er ist bei großem Volumen langsam, speicherhungrig und brüchig, wenn eine Site Automatisierung erkennt. Für die vollständige Behandlung dieses Problems, siehe wie man JavaScript-Seiten mit Python scrapt und den dedizierten Leitfaden zu Playwright Web Scraping.
Schritt 5: Paginierung folgen
Eine Seite ist eine Demo; der echte Katalog erstreckt sich über viele Seiten. Diese Site verlinkt die nächste Seite mit einem li.next a-Element, und wenn es weg ist, hat man das Ende erreicht. Also ist die Schleife einfach: die aktuelle Seite abrufen, sie parsen, den nächsten Link finden und wiederholen, bis es keinen nächsten Link mehr gibt.
import time def scrape_all(): all_rows = [] next_url = BASE + "page-1.html" while next_url: response = requests.get(next_url, headers=headers, timeout=10) if response.status_code != 200: print(f"Stopped at {next_url}: {response.status_code}") break soup = BeautifulSoup(response.text, "lxml") all_rows.extend(parse_books(soup)) next_link = soup.select_one("li.next a") next_url = urljoin(next_url, next_link["href"]) if next_link else None time.sleep(1) return all_rows
Die while next_url-Schleife läuft, bis der Nächste-Link-Selektor nichts zurückgibt, woraufhin next_url zu None wird und die Schleife natürlich endet. Das href der Site ist relativ, also löst urljoin es gegen die aktuelle Seite auf. Das time.sleep(1) zwischen Seiten ist bei einem echten Ziel keine optionale Höflichkeit: Das Dosieren von Anfragen ist der einfachste Weg, unter den Rate-Limits einer Site zu bleiben.
Schritt 6: Die Daten als CSV oder JSON speichern
Daten, die nur im Arbeitsspeicher leben, verschwinden, wenn das Skript endet. Sie auf die Festplatte schreiben, damit man sie in einem Tabellenblatt öffnen, in Pandas laden oder an das weitergeben kann, was als nächstes kommt. Pythons eingebaute csv- und json-Module verarbeiten beide Formate ohne zusätzliche Abhängigkeiten. CSV ist ideal für flache, tabellarische Datensätze; JSON behält verschachtelte Struktur und ist freundlicher zu anderen Programmen. Wenn man unsicher ist, welches man wählen soll, siehe JSON vs. CSV: Hauptunterschiede.
import csv, json def save_csv(rows, filename="books.csv"): if not rows: return with open(filename, "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=rows[0].keys()) writer.writeheader() writer.writerows(rows) def save_json(rows, filename="books.json"): with open(filename, "w", encoding="utf-8") as f: json.dump(rows, f, indent=2, ensure_ascii=False) if __name__ == "__main__": data = scrape_all() save_csv(data) save_json(data) print(f"Saved {len(data)} books")
DictWriter ordnet die Schlüssel jedes Dictionarys den CSV-Spalten zu, sodass die Kopfzeile sich aus den bereits gewählten Feldnamen selbst schreibt. newline="" verhindert Leerzeilen zwischen Zeilen unter Windows, und encoding="utf-8" hält Sonderzeichen intakt. Für größere Projekte würde man statt in eine Datei in eine Datenbank schreiben, aber die Datensätze sind identisch: Eine Liste von Dictionaries lässt sich sauber auf SQL-Zeilen oder einen Dokumentenspeicher abbilden. Das Skript ausführen und man hat einen vollständigen Export jedes Buches über jede Seite. Das ist ein vollständiger, funktionierender Scraper.
Wie die Ausgabe aussieht
Jeder Datensatz ist ein flaches Dictionary, das sich ordentlich in JSON serialisiert. Ein einzelner Eintrag aus books.json sieht so aus.
{ "title": "A Light in the Attic", "price": "£51.77", "availability": "In stock", "rating": "Three", "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html" }
Der Preis trägt noch sein Währungssymbol und die Bewertung ist ein Wort statt eine Zahl, was normal ist: Scraper erfassen, was die Seite zeigt, und ein separater Bereinigungsschritt wandelt "£51.77" in 51.77 und "Three" in 3 vor der Analyse um. Extraktion und Bereinigung als separate Schritte zu halten macht beide einfacher zu debuggen.
Warum Scraper blockiert werden und wie man entsperrt bleibt
Die Praxis-Site kämpft nie zurück, aber echte Ziele tun es. Zwei Wände tauchen in dem Moment auf, wenn man skaliert, und keine lässt sich durch das Anpassen von Selektoren lösen.
Die erste ist Anti-Bot-Abwehr. Datacenter-IPs, repetitive Anfragemuster und Traffic, der nicht wie ein echter Browser aussieht, werden mit CAPTCHAs herausgefordert oder direkt blockiert. Der Scraper könnte zehn Anfragen lang funktionieren und dann beginnen, 403-Fehler oder leere Seiten zurückzugeben. Die zweite ist Client-seitiges Rendering, behandelt in Schritt 4: Ein bloßer Abruf kann Inhalte nicht sehen, die der Browser mit JavaScript aufbaut. Man kann beides selbst bekämpfen, indem man einen Pool rotierender Residential-Proxies pflegt und eine Headless-Browser-Flotte betreibt, aber diese zusammenzusetzen und gesund zu halten ist der Großteil des Engineering-Aufwands, und nichts davon sind die Daten, die man eigentlich will.
Eine verwaltete Crawling-API fasst beides in einer einzigen Anfrage zusammen. Man sendet ihr die URL, sie rendert die Seite in einem echten Browser hinter einer vertrauenswürdigen rotierenden IP und gibt fertiges HTML für denselben Parser zurück, den man bereits geschrieben hat. Den offiziellen Client neben den bestehenden Bibliotheken installieren.
pip install crawlbase
Das Crawlbase-Token bereithalten; es ist der Authentifizierungsschlüssel für jeden Aufruf. Der Austausch ist eine Zeile: Wo man requests.get aufgerufen hat, ruft man stattdessen die API auf, und das zurückgegebene HTML fließt in dieselbe parse_books-Funktion.
from crawlbase import CrawlingAPI api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"}) def fetch(url): options = {"ajax_wait": "true", "page_wait": 2000} result = api.get(url, options) if result["status_code"] == 200: return result["body"].decode("utf-8") return None html = fetch(url) soup = BeautifulSoup(html, "lxml") # same parser, unchanged rows = parse_books(soup)
Die Optionen ajax_wait und page_wait sind bei einem Client-gerenderten Ziel wichtig: ajax_wait wartet darauf, dass asynchroner Inhalt fertig ist, und page_wait hält für eine feste Anzahl von Millisekunden, damit späte Elemente vor der Erfassung erscheinen. Da die API HTML zurückgibt, ist das Einsetzen eine einzeilige Änderung statt einer Umschreibung. Für das vollständige Anti-Blockierungs-Playbook, einschließlich Header-Strategie und Proxy-Rotation, siehe wie man Websites scrapt, ohne blockiert zu werden.
Crawlbase bietet ein normales Token zum Abrufen von statischem HTML und ein JavaScript-Token, das die Seite zuerst in einem echten Browser rendert. Das normale Token für statische Seiten wie den Übungskatalog verwenden; zum JavaScript-Token wechseln für jede Site, die ihren Inhalt Client-seitig aufbaut. Wenn geparste Felder bei einem echten Ziel leer zurückkommen, ist das JavaScript-Token normalerweise die Lösung.
Über ein einzelnes Skript hinaus skalieren
Das Abrufen-Parsen-Schleifen-Speichern-Muster trägt einen weit, aber zwei Bedürfnisse drängen schließlich über ein einzelnes Skript hinaus. Das erste ist Nebenläufigkeit: Seiten eine nach der anderen zu scrapen ist langsam, sobald man Tausende von URLs hat. Das zweite ist Struktur: Wiederholungen, Deduplizierung und Datenpipelines gehören nicht in eine Ad-hoc-Schleife. Hier verdient Scrapy seinen Platz. Es gibt parallele Anfragen, automatische Wiederholungen, Anfragenplanung und Item-Pipelines aus der Box, sodass man beschreibt, was zu extrahieren ist, und das Framework die Orchestrierung übernimmt.
Selbst mit Scrapy verschwinden die zwei Wände aus dem vorherigen Abschnitt nicht: Man braucht immer noch Rendering für JavaScript-Seiten und vertrauenswürdige IPs, um Blockierungen im großen Volumen zu vermeiden. Die saubere Trennung ist, das Framework Nebenläufigkeit und Pipelines verwalten zu lassen, während eine verwaltete API Rendering und Rotation übernimmt, sodass der Downloader einer Scrapy-Spider jede Anfrage einfach durch die Crawling API leitet. Das hält den Code bei den Daten und lagert die Infrastruktur aus, die nichts damit zu tun hat.
Verantwortungsvoll und legal scrapen
Das Scrapen öffentlicher Daten ist im Allgemeinen zulässig, aber wie man es tut und was man erfasst, ist wichtiger als die Handlung selbst. Bevor man einen Scraper auf eine Site richtet, deren robots.txt und Nutzungsbedingungen lesen: Das erste signalisiert, welche Pfade die Site automatisierte Clients zu meiden bittet, und das zweite legt die Regeln fest, denen man durch die Nutzung zustimmt. Anfragen dosieren, damit man den Server nie belastet, den Client ehrlich identifizieren und die offizielle API einer Site bevorzugen, wenn eine existiert, da eine API der Zugriffspfad ist, den der Besitzer tatsächlich für programmatische Nutzung gebaut hat, und sie spart einem die Fragilität des HTML-Parsens.
Auf der richtigen Seite der Linie bleiben, indem man die Erfassung auf öffentliche, nicht personenbezogene Daten beschränkt. Alles hinter einem Login, alles, das das Akzeptieren von Bedingungen erfordert, die man umgehen würde, und personenbezogene Daten, die von Datenschutzregimen wie der DSGVO und dem CCPA abgedeckt werden, vermeiden, wo die Erfassung Zustimmung und eine rechtliche Grundlage erfordern kann. Urheberrechtlich geschützte Medien, die man scrapt, nicht weiterverbreiten, und wenn ein Projekt kommerziell ist oder regulierte Daten berührt, das rechtliche Einverständnis einholen, das man für jede andere Datenquelle einholen würde. Verantwortungsvolles Scraping ist meistens gesunder Menschenverstand: Nur nehmen, was öffentlich ist, es behutsam nehmen und die Wünsche respektieren, die die Site bereits veröffentlicht hat.
Wichtigste Erkenntnisse
- Die Kernschleife ist abrufen, parsen, schleifen, speichern. requests holt das HTML, BeautifulSoup extrahiert Felder, die Paginierung geht die Seiten durch, und das csv- oder json-Modul speichert das Ergebnis.
- Das Werkzeug der Seite anpassen. requests und BeautifulSoup decken statische Sites ab; Playwright oder Selenium rendern JavaScript; Scrapy fügt Nebenläufigkeit und Pipelines im großen Maßstab hinzu.
- Vor dem Auswählen inspizieren. Die Dev-Tools der Seite öffnen, um die Tags und Klassen zu finden, die die Daten enthalten, dann jedes Feld einem CSS-Selektor zuordnen.
- Einfaches requests hat zwei Grenzen. Es kann kein JavaScript ausführen und wird im großen Maßstab blockiert, was keiner von Selektoren beheben kann.
- Eine verwaltete API löst beides in einem Aufruf. Die Crawling API rendert die Seite hinter einer vertrauenswürdigen rotierenden IP und gibt fertiges HTML zurück, sodass der vorhandene Parser unverändert weiterarbeitet.
Häufig gestellte Fragen
Was ist Web Scraping?
Web Scraping ist die automatisierte Extraktion von Daten aus Webseiten. Ein Skript fordert eine URL an, der Server gibt HTML zurück, und ein Parser zieht die spezifischen Felder heraus, die man möchte, und speichert sie in einem strukturierten Format wie CSV, JSON oder einer Datenbank. So verwandelt man für menschliche Lektüre gebaute Seiten in Daten, die man im großen Maßstab abfragen und analysieren kann.
Welche Python-Bibliotheken braucht man zum Starten?
Für eine typische statische Site reichen requests und BeautifulSoup: requests lädt die Seite und BeautifulSoup extrahiert Felder nach Tag und CSS-Klasse. lxml für schnelleres Parsen und XPath-Unterstützung hinzufügen, Playwright oder Selenium wenn eine Site mit JavaScript rendert, und Scrapy wenn man Nebenläufigkeit und Pipelines für ein größeres Projekt braucht.
Warum sind meine gescrapten Daten leer, wenn die Seite offensichtlich Inhalt hat?
Fast immer weil die Site ihren Inhalt mit JavaScript rendert. requests ruft nur die initiale HTML-Hülle ab und führt keine Skripte aus, sodass die Daten, die man im Browser sieht, nicht in dem vorhanden sind, was man parst. Die Seite zuerst rendern, entweder mit einem Headless-Browser oder mit dem JavaScript-Token der Crawling API, bevor BeautifulSoup die Felder finden kann.
Wie scrapt man mehrere Seiten?
Den Link oder das Muster finden, das die Site für ihre nächste Seite verwendet, dann schleifen. Wenn es eine "Weiter"-Schaltfläche gibt, ihrem href folgen, bis sie verschwindet, wie in Schritt 5 gezeigt. Wenn die URLs einem Zahlenmuster wie page-2.html folgen, kann man sie stattdessen in einer Range-Schleife aufbauen. In jedem Fall eine kurze Verzögerung zwischen Seiten hinzufügen, um höflich und entsperrt zu bleiben.
Wie vermeidet man Blockierungen beim Scraping?
Anfragen mit einer Verzögerung dosieren, einen realistischen User-Agent-Header senden und nicht auf einem einzigen Pfad hämmern. Im großen Maßstab braucht man auch IPs, die wie echte Besucher aussehen, was eine Maschine nicht liefern kann. Durch rotierende Residential-IPs zu leiten, ob über die Crawling API oder den Smart AI Proxy, ist es, was hochvolumige Durchläufe davon abhält, Rate-Limits und CAPTCHAs auszulösen.
Ist Web Scraping legal?
Das Scrapen öffentlicher Daten ist im Allgemeinen zulässig, aber das hängt von den Nutzungsbedingungen der Site, Ihrer Zuständigkeit und dem ab, was Sie mit den Daten tun. Das robots.txt und die Nutzungsbedingungen prüfen, bevor man beginnt, personenbezogene Daten, die von Datenschutzgesetzen wie der DSGVO und dem CCPA abgedeckt werden, vermeiden, niemals Inhalte hinter einem Login scrapen und eine offizielle API bevorzugen, wenn eine existiert. Im Zweifel nur öffentliche Daten erfassen und das Volumen niedrig genug halten, damit man den Server nicht belastet.
Crawlen Sie jede Website im großen Maßstab, ohne gegen die Infrastruktur zu kämpfen.
Crawlbase übernimmt Proxys, Fingerprints und CAPTCHAs, damit Ihr Team Datenpipelines ausliefert, statt Crawl-Infrastruktur zu pflegen. 1.000 Anfragen kostenlos, keine Karte erforderlich.