Die meisten Scraping-Tutorials zeigen Ihnen, wie Sie eine Seite abrufen und sie sofort parsen. Diese synchrone Schleife funktioniert gut, bis Sie Tausende von Seiten benötigen; dann verbringt Ihr Skript sein Leben mit Warten: eine URL einreichen, blockieren, bis die Antwort zurückkommt, parsen, wiederholen. Wiederholungsversuche, Warteschlangen, Proxy-Rotation und Rendering stapeln sich alle auf demselben Thread, und ein langsames Ziel lähmt den gesamten Lauf. Im großen Maßstab möchten Sie eine völlig andere Struktur.
Diese Anleitung zeigt Ihnen, wie Sie Daten mit dem Crawlbase Crawler extrahieren, dem asynchronen, push-basierten Produkt für Massenaufgaben. Anstatt auf jede Anfrage zu warten, senden Sie einen Stapel URLs an den Crawler und er crawlt sie in großem Maßstab auf seiner eigenen Infrastruktur, dann liefert er jedes fertige Ergebnis an einen Webhook-Endpunkt, den Sie kontrollieren. Einreichung und Empfang sind entkoppelt, sodass Ihr Code niemals blockiert und auf eine Seite wartet. Am Ende werden Sie einen funktionierenden Callback-Server, einen benannten Crawler und ein Skript haben, das URLs einschickt und geparste Daten auf der anderen Seite empfängt.
Synchron vs. asynchron: das richtige Werkzeug wählen
Crawlbase bietet Ihnen zwei Möglichkeiten, eine Seite abzurufen, und der Unterschied betrifft das Timing, nicht die Fähigkeit. Die Crawling API ist synchron: Sie senden eine Anfrage, Sie warten, das gerenderte HTML kommt in derselben Antwort zurück. Das ist ideal, wenn Sie eine Seite genau jetzt benötigen und das Ergebnis inline haben möchten.
Der Crawler ist die asynchrone Schicht, die auf demselben Motor aufbaut. Sie senden eine URL und erhalten sofort eine Bestätigung mit einer Anfrage-ID zurück, nicht mehr. Das eigentliche Crawlen findet im Hintergrund auf Crawlbase-Servern statt, und wenn eine Seite fertig ist, wird das Ergebnis per POST an Ihre Callback-URL geschickt. Sie halten nie eine Verbindung offen; Sie können also Tausende von URLs in Sekunden absenden und die Ergebnisse zurück zu Ihrem Endpunkt streamen lassen, wenn sie fertig sind.
Verwenden Sie die Crawling API für interaktive Einzelabrufe, bei denen Sie die Seite inline benötigen. Greifen Sie zum Crawler, wenn Sie in großem Maßstab crawlen: große Listen, wiederkehrende Jobs oder alles, bei dem das Blockieren bei jeder Anfrage den Durchsatz beeinträchtigen würde. Der Crawler absorbiert Warteschlangen, Wiederholungsversuche, Proxy-Rotation und JavaScript-Rendering für Sie und liefert fertige Daten über Ihren Webhook zurück.
Wie das Push-Modell funktioniert
Der Ablauf hat drei bewegliche Teile, und es hilft, alle drei im Kopf zu behalten, bevor Sie Code schreiben.
Erstens ein Crawler: eine benannte Konfiguration, die Sie einmal im Dashboard erstellen. Sie verknüpft eine Callback-URL mit einem Anfrage-Typ (normal oder JavaScript), sodass die Engine weiß, wohin die Ergebnisse geliefert und wie gerendert werden soll. Zweitens die Push-Anfrage: Sie rufen die API mit Ihrem Token, der Ziel-URL und Ihrem Crawler-Namen auf, und sie gibt eine JSON-Bestätigung mit einer eindeutigen Anfrage-ID (der RID) zurück. Drittens der Callback: Wenn die Seite gecrawlt ist, sendet Crawlbase eine HTTP-POST-Anfrage an Ihre Callback-URL mit dem Seiteninhalt und derselben RID, sodass Sie jede Lieferung der URL zuordnen können, die Sie eingereicht haben.
Ihr Callback-Endpunkt muss zwei Bedingungen erfüllen. Er muss öffentlich von Crawlbase-Servern erreichbar sein, und er muss schnell antworten: Antworten Sie auf den POST innerhalb von einigen hundert Millisekunden mit einem Status 200, 201 oder 204. Der Inhalt kommt GZIP-komprimiert an und standardmäßig als HTML; Sie können stattdessen geparsten JSON anfordern, indem Sie das Format bei der Anfrage festlegen. Da die Arbeit asynchron ist, besteht Ihre Aufgabe auf der Empfängerseite darin, schnell zu bestätigen und die Nutzlast an eine Warteschlange oder eine Datenbank weiterzugeben, nicht schwere Verarbeitung inline durchzuführen.
Was Sie bauen werden
Eine vollständige Rundreise in Python. Sie richten einen kleinen Flask-Webhook ein, der gecrawlte Seiten empfängt, ihn ins Internet exponieren, sodass Crawlbase ihn erreichen kann, einen benannten Crawler im Dashboard erstellen, der auf diese öffentliche URL zeigt, und schließlich Ziel-URLs mit dem offiziellen crawlbase-Client einreichen. Wir verwenden öffentliche Testseiten, damit Sie jeden Schritt ausführen können, bevor Sie es auf echte Ziele richten.
Die Umgebung einrichten
Sie benötigen Python 3.8 oder höher. Bestätigen Sie Ihre Version, erstellen Sie eine virtuelle Umgebung, damit die Abhängigkeiten isoliert bleiben, und installieren Sie dann die beiden Bibliotheken: Flask für den Webhook-Server und den offiziellen Crawlbase-Client zum Einreichen von Anfragen.
python --version python -m venv crawler_env source crawler_env/bin/activate pip install flask crawlbase
Unter Windows aktivieren Sie die Umgebung mit crawler_env\Scripts\activate anstelle der source-Zeile. Sie benötigen außerdem Ihr Crawlbase-Token aus dem Dashboard. Crawlbase bietet zwei Token-Typen an: das normale Token für einfache HTTP-Abrufe und das JavaScript-Token für Seiten, die Inhalte clientseitig in einem echten Browser rendern. Wählen Sie das, das zu den Seiten passt, die Sie anvisieren; die meisten modernen Seiten benötigen das JavaScript-Token.
Schritt 1: Den Webhook zum Empfang gecrawlter Daten bauen
Der Callback-Endpunkt ist der Ort, an dem fertige Seiten ankommen. Erstellen Sie eine Datei namens webhook.py. Der Handler liest den POST-Body, protokolliert die RID, damit Sie sie mit der Push-Antwort korrelieren können, und gibt sofort 200 zurück. Flask dekomprimiert den GZIP-Body für Sie, sodass der Inhalt zum Zeitpunkt des Lesens normaler Text ist.
from flask import Flask, request app = Flask(__name__) @app.route("/crawlbase", methods=["POST"]) def webhook(): rid = request.headers.get("rid") original_url = request.headers.get("original_url") body = request.get_data(as_text=True) print(f"Received RID {rid} for {original_url}") print(f"Payload size: {len(body)} bytes") # Hand the payload to a queue or database here; keep this fast. return "", 200 if __name__ == "__main__": app.run(port=3000)
Einige Details sind hier wichtig. Crawlbase sendet die Anfrage-ID in einem rid-Header und die gecrawlte URL in original_url, sodass Sie nie raten müssen, zu welcher Einreichung eine Lieferung gehört. Der Handler macht keine schwere Arbeit: er bestätigt und gibt zurück. Das Zweihundert-Millisekunden-Antwortfenster ist streng; alles Langsame (Parsen, Schreiben in einen langsamen Datenspeicher, Aufrufen eines anderen Dienstes) gehört in eine Hintergrundwarteschlange, nicht in die Anfrage. Starten Sie den Server und lassen Sie ihn in seinem eigenen Terminal laufen.
python webhook.py
Schritt 2: Den lokalen Server ins Internet exponieren
Crawlbase-Server müssen Ihren Callback erreichen können, und ein Server auf localhost ist von außen nicht erreichbar. Während der Entwicklung ist die einfachste Lösung ein Tunneling-Tool wie ngrok, das Ihrem lokalen Port eine öffentliche HTTPS-URL gibt. Mit dem noch laufenden Webhook auf Port 3000 öffnen Sie ein zweites Terminal und starten den Tunnel.
ngrok http 3000
ngrok gibt eine öffentliche Weiterleitungs-URL aus, etwa https://random-id.ngrok-free.app. Ihre vollständige Callback-URL ist dieser Host plus die Route aus der Flask-App, also https://random-id.ngrok-free.app/crawlbase. Lassen Sie auch dieses Terminal offen; die URL ändert sich jedes Mal, wenn Sie den Tunnel neu starten. In der Produktion würden Sie den Crawler auf einen echten, stabilen Endpunkt auf Ihrer eigenen Infrastruktur zeigen lassen.
Tunneling ist eine Entwicklungshilfe, keine Deployment-Strategie. Für echte Workloads hosten Sie den Webhook auf einem Dienst mit einer stabilen öffentlichen URL und verifizieren Sie jede eingehende Anfrage, bevor Sie ihr vertrauen, zum Beispiel indem Sie prüfen, dass die RID einer tatsächlich eingeschickten entspricht. Behandeln Sie den Callback als nicht vertrauenswürdigen öffentlichen Endpunkt, denn das ist er.
Schritt 3: Einen Crawler im Dashboard erstellen
Eine Push-Anfrage benötigt einen benannten Crawler, damit die Engine weiß, wohin die Ergebnisse geliefert werden sollen. Gehen Sie in Ihrem Crawlbase-Dashboard zum Crawler-Bereich und erstellen Sie einen neuen Crawler. Sie geben ihm einen eindeutigen Namen, fügen Ihre öffentliche Callback-URL ein (die ngrok-URL plus /crawlbase) und wählen den Anfrage-Typ: normal für einfaches HTML oder JavaScript für clientseitig gerenderte Seiten. Speichern Sie ihn, und der Crawler erscheint in Ihrer Liste, bereit, Pushes zu empfangen.
Der Name, den Sie wählen, ist der Wert, den Sie bei jeder Push-Anfrage übergeben; halten Sie ihn daher einfach und einprägsam. Ein gängiges Muster ist ein Crawler pro Projekt oder Datenquelle, jeder auf eine Route Ihres Servers zeigend, die dieser unterscheiden kann.
Der Crawler ist die asynchrone, push-basierte Methode zum Scrapen im großen Maßstab. Senden Sie Tausende von URLs in Sekunden und lassen Sie fertige Seiten zu Ihrem Webhook streamen, während die Engine Warteschlangen, Wiederholungsversuche, Proxy-Rotation und JavaScript-Rendering auf ihrer eigenen Infrastruktur verwaltet. Erstellen Sie Ihren ersten Crawler im kostenlosen Kontingent und richten Sie ihn auf eine öffentliche Testseite.
Schritt 4: URLs an den Crawler senden
Mit dem live geschalteten Webhook, dem offenen Tunnel und einem erstellten Crawler sind Sie bereit zum Senden. Der offizielle crawlbase-Client verpackt die API; ein Push ist also ein einziger get-Aufruf mit zwei zusätzlichen Optionen: callback auf true gesetzt und crawler auf den von Ihnen registrierten Namen. Erstellen Sie eine Datei namens push.py.
from crawlbase import CrawlingAPI api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"}) target = "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html" response = api.get(target, { "callback": "true", "crawler": "my-crawler", "format": "json", }) print(response["body"])
Führen Sie es mit python push.py aus. Die Antwort ist nicht der Seiteninhalt. Es ist eine sofortige Bestätigung mit der Anfrage-ID, was genau das bedeutet, was asynchron bedeutet: Der Aufruf kehrt zurück, bevor das Crawlen abgeschlossen ist. Sie erhalten so etwas zurück:
{ "rid": "e2bbac4e7ea9a4c4be57d2a4" }
Eine oder zwei Sekunden später kommt die gecrawlte Seite bei Ihrem Webhook an. Überprüfen Sie das Terminal, auf dem webhook.py läuft, und Sie sehen dieselbe RID ausgegeben, was bestätigt, dass der Rundtrip abgeschlossen ist: Die Engine hat die Seite im Hintergrund gecrawlt und das fertige Ergebnis per POST an Ihren Callback geschickt. Das Setzen von format auf json beim Push bedeutet, dass die gelieferte Nutzlast geparsten JSON statt rohem HTML ist, was Sie in der Regel für die nachgelagerte Verarbeitung bevorzugen.
Im Massenverfahren senden
Eine URL beweist die Verkabelung; der Sinn des Crawlers ist das Volumen. Eine Liste zu senden ist nur eine Schleife, und da jeder Aufruf sofort zurückkehrt, können Sie einen großen Stapel in Sekunden einreichen, ohne auf einen einzelnen Crawl zu warten. Der Crawler hat eine großzügige Push-Warteschlange; Sie füttern ihn weiter und lassen die Ergebnisse nach eigenem Zeitplan am Webhook ankommen.
from crawlbase import CrawlingAPI api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"}) urls = [ "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html", "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html", "https://books.toscrape.com/catalogue/soumission_998/index.html", ] for url in urls: response = api.get(url, { "callback": "true", "crawler": "my-crawler", "format": "json", }) print(f"Pushed {url} -> {response['body']}")
Jede Iteration gibt ihre eigene RID zurück, und Ihr Webhook empfängt einen separaten POST pro URL, wenn jeder Crawl abgeschlossen ist. Speichern Sie die RID-Liste auf der Push-Seite und gleichen Sie sie gegen die Lieferungen auf der Callback-Seite ab, damit Sie alles erkennen, was nie zurückgekommen ist, und es erneut senden können. Diese Abgleich-Schleife ist das Rückgrat einer zuverlässigen Massen-Pipeline und fügt sich natürlich in eine größere skalierbare Web-Datenpipeline ein.
Die geernteten Daten validieren und verwenden
Daten zu empfangen ist nicht dasselbe wie ihnen zu vertrauen. Bevor die Nutzlast Ihr Lager erreicht, validieren Sie sie auf der Callback-Seite: Bestätigen Sie, dass die RID einer eingeschickten entspricht, prüfen Sie den Statuscode, den Crawlbase für den Crawl meldet, und verifizieren Sie, dass die erwarteten Felder vorhanden und nicht leer sind. Eine Seite kann auf HTTP-Ebene erfolgreich zurückkommen, während ein Redesign oder eine weiche Blockierung den Inhalt, den Sie benötigen, fehlen lässt; eine schnelle Schema-Prüfung erkennt stille Lücken frühzeitig.
Einmal validiert, speisen die geernteten Daten die üblichen Geschäftsanforderungen: Preis- und Bestandsüberwachung über Wettbewerber, Lead- und Kontaktanreicherung, Markt- und Stimmungsforschung, Trainingssets für Modelle oder das Synchronhalten eines internen Katalogs mit externen Quellen. Da der Crawler Ergebnisse kontinuierlich statt in einem blockierenden Stapel liefert, passt er natürlich in Streaming- und inkrementelle Pipelines, in denen frische Daten ankommen, sobald jede Seite gecrawlt ist. Mehr dazu, wie Sie in großem Maßstab saubere Ergebnisse erzielen, finden Sie unter Websites scrapen ohne blockiert zu werden.
Wenn Sie stattdessen Ihren eigenen Datenverkehr routen möchten statt das Push-Modell zu verwenden, bietet der Smart AI Proxy dieselben rotierenden Residential-IPs als Drop-in-Endpunkt, und die Crawling API gibt vorparstes JSON für unterstützte Seiten zurück, wenn Sie strukturierte Felder ohne Verwaltung des Parsings möchten.
Wichtigste Erkenntnisse
- Asynchron by Design. Der Crawler entkoppelt Einreichung von Empfang: Sie senden URLs und erhalten sofort eine RID, dann werden Ergebnisse per POST an Ihren Webhook geliefert, wenn jeder Crawl abgeschlossen ist.
- Drei bewegliche Teile. Ein benannter Crawler im Dashboard, eine Push-Anfrage mit Ihrem Token und Crawler-Namen, und ein Callback-Endpunkt, der die Daten und die passende RID empfängt.
- Schnell antworten. Ihr Webhook muss öffentlich erreichbar sein und innerhalb von etwa 200 Millisekunden mit einem 2xx antworten; bestätigen Sie also und lagern Sie schwere Arbeit in eine Warteschlange aus.
- Für Massen ausgelegt. Da jeder Push sofort zurückkehrt, können Sie Tausende von URLs in Sekunden einreichen und die Engine Warteschlangen, Wiederholungsversuche, Proxys und Rendering verwalten lassen.
- Vor dem Vertrauen validieren. Gleichen Sie RIDs ab und prüfen Sie, dass erwartete Felder vorhanden sind, damit stille Lücken durch Redesigns oder weiche Blockierungen nicht in Ihre Daten gelangen.
Häufig gestellte Fragen
Was ist der Unterschied zwischen dem Crawler und der Crawling API?
Die Crawling API ist synchron: Sie senden eine Anfrage und die gerenderte Seite kommt in derselben Antwort zurück, was ideal für einmalige, interaktive Abrufe ist. Der Crawler ist die asynchrone Schicht auf demselben Motor: Sie senden eine URL, erhalten sofort eine Anfrage-ID, und die fertige Seite wird später an Ihren Webhook geliefert. Verwenden Sie die Crawling API für Inline-Ergebnisse und den Crawler für Massenaufgaben, bei denen das Blockieren bei jeder Anfrage den Durchsatz begrenzen würde.
Warum muss mein Webhook öffentlich zugänglich sein?
Crawlbase-Server liefern gecrawlte Seiten, indem sie eine HTTP-POST-Anfrage an Ihre Callback-URL senden; sie müssen also in der Lage sein, sie über das Internet zu erreichen. Ein Server auf localhost ist von außerhalb Ihres Rechners unsichtbar, weshalb Sie ihn während der Entwicklung mit einem Tunneling-Tool wie ngrok exponieren. In der Produktion hosten Sie den Webhook auf einem Dienst mit einer stabilen öffentlichen URL.
Was gibt die Push-Anfrage zurück?
Sie gibt eine kleine JSON-Bestätigung zurück, die eine eindeutige Anfrage-ID, die RID, enthält, nicht den Seiteninhalt. Das ist der asynchrone Vertrag: Der Aufruf kehrt sofort zurück, während der Crawl im Hintergrund läuft. Die eigentliche Seite kommt später an Ihrem Webhook an und trägt dieselbe RID in ihren Headern, sodass Sie jede Lieferung der URL zuordnen können, die Sie eingereicht haben.
Wie schnell muss mein Callback antworten?
Innerhalb von etwa 200 Millisekunden, mit einem Statuscode 200, 201 oder 204. Crawlbase erwartet eine schnelle Bestätigung; Ihr Handler sollte also die Nutzlast lesen, sie an eine Warteschlange oder Datenbank weitergeben und zurückgeben. Alles Langsame, wie Parsen oder Schreiben in einen langsamen Datenspeicher, gehört in einen Hintergrund-Worker statt in die Anfrage.
Kann ich geparsten JSON statt rohem HTML empfangen?
Ja. Standardmäßig liefert der Crawler HTML, aber Sie können das Format bei der Push-Anfrage auf JSON setzen, und die Nutzlast kommt geparst an. Wählen Sie die Form, die Ihr nachgelagerter Code bevorzugt; JSON ist in der Regel einfacher für die strukturierte Extraktion zu verarbeiten, während HTML praktisch ist, wenn Sie Ihren eigenen Parser über die gesamte Seite laufen lassen möchten.
Wie mache ich einen Massen-Crawl zuverlässig?
Verfolgen Sie die RID für jede URL, die Sie einreichen, und gleichen Sie diese Liste gegen die Lieferungen ab, die Ihren Webhook erreichen. Alles, was nie ankommt, kann erneut gesendet werden. Validieren Sie auf der Empfängerseite jede Nutzlast, indem Sie die RID bestätigen, den gemeldeten Crawl-Status prüfen und verifizieren, dass erwartete Felder vorhanden sind, damit eine erfolgreich aussehende Antwort mit fehlendem Inhalt nicht unbemerkt durchschlüpft.
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.