Web Scraping mit ChatGPTMit Crawlbase abrufen, mit KI extrahieren

ChatGPT Web Scraping hat die Art, wie ein Großteil des Extraktionscodes geschrieben wird, still und leise verändert. Die alte Methode war spröde: eine Seite inspizieren, CSS-Selektoren von Hand schreiben und sie bei jedem neuen Markup-Deployment umschreiben. Die neue Methode setzt auf das Modell. Man lädt eine saubere Kopie der Seite, übergibt sie einem OpenAI-Modell und fragt nach den gewünschten Feldern als strukturiertes JSON. Die Selektoren stecken im Prompt statt im Code, und sie überleben Layout-Änderungen, die einen hardcodierten Parser gebrochen hätten.

Es gibt einen ehrlichen Vorbehalt, den das Marketing gerne übersieht: ChatGPT kann die Seite nicht für Sie abrufen. Es hat keinen zuverlässigen Browser, wird wie jeder andere Client geblockt, und das Bitten um eine Live-URL liefert oft eine selbstsichere Halluzination statt echter Daten. Dieser Leitfaden teilt die Aufgabe deshalb sauber auf. Crawlbase übernimmt das Abrufen und Rendering hinter einer vertrauenswürdigen IP, das OpenAI-Modell das Verstehen, und Python verbindet beides. Alles unten ist ausführbar, auf öffentliche Seiten beschränkt und so gebaut, dass es mit Seiten umgeht, die zu groß sind, um sie in einem Schritt an das Modell zu senden.

Wie ChatGPT Web Scraping tatsächlich funktioniert

Es hilft, präzise zu sein, welches Werkzeug was tut, denn die Verwechslung der beiden ist der Fehler, den die meisten Tutorials machen. Ein Sprachmodell ist eine Reasoning-Schicht, kein Netzwerk-Client. Gibt man ihm sauberen Text, ist es hervorragend darin, strukturierte Felder aus unstrukturiertem Inhalt zu ziehen. Fordert man es auf, diesen Inhalt selbst zu besorgen, versagt es: kein Rendering-Engine, kein Proxy-Pool, keine CAPTCHA-Behandlung und eine starke Neigung, plausibel klingende Werte zu erfinden, wenn es die Seite nicht wirklich laden kann.

Eine funktionierende Pipeline hat also drei Stufen. Zuerst wird das Ziel mit der Crawling API abgerufen und gerendert, die die Seite in einem echten Browser hinter rotierenden residential IPs ausführt und fertiges HTML zurückgibt. Zweite Stufe: das HTML auf etwas Kompaktes reduzieren, entweder reinen Text oder Markdown, damit man nicht dafür zahlt, Navigation und Script-Tags an das Modell zu senden. Dritte Stufe: ein OpenAI-Modell mit einem Prompt beauftragen, diesen Inhalt zu lesen und JSON gemäß einem selbst definierten Schema zurückzugeben. Das Modell berührt niemals das Netzwerk; es liest nur, was man ihm gibt.

Was man vor dem Start benötigt

Das ist ein Einsteiger-bis-Fortgeschrittenen-Build. Man benötigt Python 3.9 oder neuer, ein Crawlbase-Konto für einen normalen und einen JavaScript-Token sowie einen OpenAI-API-Key. Der kostenlose Crawlbase-Tarif umfasst mehr als genug Anfragen, um die Beispiele nachzuvollziehen, und die Modellaufrufe hier verwenden ein kleines, günstiges Modell. Beide Secrets als Umgebungsvariablen setzen statt in das Skript einzufügen.

python --version

mkdir chatgpt-scraper && cd chatgpt-scraper
pip install crawlbase openai beautifulsoup4 html2text

export CRAWLBASE_TOKEN="your_normal_token"
export CRAWLBASE_JS_TOKEN="your_javascript_token"
export OPENAI_API_KEY="your_openai_key"

Vier Bibliotheken erledigen die Arbeit. crawlbase ist der Client für die Crawling API, openai ist das offizielle SDK für die Modellaufrufe, beautifulsoup4 reduziert eine gerenderte Seite auf lesbaren Text, und html2text wandelt HTML in Markdown um, wenn das Modell die Struktur wie Überschriften und Tabellen sehen soll. Man braucht nicht immer sowohl BeautifulSoup als auch html2text; man wählt die Darstellung, die zur Seite passt.

Schritt 1: Die gerenderte Seite mit der Crawling API abrufen

Beginnen Sie damit, eine saubere Kopie der Seite zu erhalten. Verwenden Sie den JavaScript-Token für jede Site, die Inhalte client-seitig rendert, was die meisten modernen Seiten tun, und übergeben Sie ajax_wait plus page_wait, damit spät ladende Inhalte Zeit haben zu erscheinen, bevor das HTML zurückkommt. Das folgende Beispiel zeigt auf eine öffentliche Produktseite; ersetzen Sie es durch die öffentliche URL, mit der Sie arbeiten.

import os
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": os.environ["CRAWLBASE_JS_TOKEN"]})

target_url = "https://www.example.com/products/widget"

def fetch_html(url):
    response = api.get(url, {"ajax_wait": "true", "page_wait": 4000})
    if response["status_code"] != 200:
        raise RuntimeError(f"Fetch failed: {response['status_code']}")
    return response["body"].decode("utf-8", "ignore")

if __name__ == "__main__":
    html = fetch_html(target_url)
    print(len(html), "bytes of rendered HTML")

Führen Sie es aus, und Sie sollten eine substanzielle Bytezahl sehen und, wenn Sie einen Ausschnitt ausgeben, echten Inhalt statt einer leeren Hülle. Das ist der Schritt, den ChatGPT nicht allein kann: Die Crawling API hat JavaScript gerendert und die Anfrage durch eine vertrauenswürdige IP geleitet, sodass die Seite vollständig zurückgekommen ist. Mit sauberem HTML in der Hand kann das Modell übernehmen.

Schritt 2: Die Seite auf sauberen Text oder Markdown reduzieren

Rohes HTML ist für ein Sprachmodell größtenteils Rauschen: Skripte, Styles, SVG-Pfade und Tracking-Tags, die Token kosten und das Signal verwässern. Entfernen Sie diese zuerst. Für einfache Feldextraktion reicht BeautifulSoup-Text. Wenn die Seite eine sinnvolle Struktur hat, wie eine Spezifikationstabelle oder eine verschachtelte Liste, konvertieren Sie zu Markdown, damit das Modell die Hierarchie sehen kann.

from bs4 import BeautifulSoup
import html2text

def to_text(html):
    soup = BeautifulSoup(html, "html.parser")
    for tag in soup(["script", "style", "noscript", "svg"]):
        tag.decompose()
    return soup.get_text(separator=" ", strip=True)

def to_markdown(html):
    converter = html2text.HTML2Text()
    converter.ignore_links = True
    converter.ignore_images = True
    return converter.handle(html)

Dieser eine Schritt reduziert die Token-Anzahl oft um eine Größenordnung, was günstigere, schnellere und genauere Extraktionen ergibt, weil das Modell nicht durch Markup waten muss. Wenn Sie diesen Schritt ganz überspringen möchten, kann Crawlbase direkt aus dem Abruf sauberes LLM-fertiges Markdown zurückgeben, sodass die Seite in der Form ankommt, die ein Modell möchte, ohne einen lokalen Konvertierungsschritt.

Schritt 3: Das OpenAI-Modell mit einem Prompt zur Extraktion strukturierter JSON beauftragen

Jetzt das eigentliche ChatGPT Web Scraping. Senden Sie den bereinigten Inhalt an ein OpenAI-Modell mit einem Prompt, der jedes gewünschte Feld benennt und die Ausgabe zu JSON zwingt. Die wichtigste Einstellung ist das Anfordern einer JSON-Objekt-Antwort, damit man parsierbare Daten statt Prosa erhält. Eine niedrige Temperatur hält das Modell davon ab, bei Werten kreativ zu werden, die wörtlich kopiert werden sollten.

import json
from openai import OpenAI

client = OpenAI()

SYSTEM = (
    "You extract structured data from web page content. "
    "Return only valid JSON. Copy values verbatim from the text. "
    "If a field is not present, use null. Never invent data."
)

def extract(content, fields):
    prompt = (
        f"Extract these fields as JSON: {', '.join(fields)}.\n\n"
        f"Page content:\n{content}"
    )
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        temperature=0,
        response_format={"type": "json_object"},
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": prompt},
        ],
    )
    return json.loads(response.choices[0].message.content)

Verbinden Sie die drei Stufen, und Sie haben einen vollständigen Scraper, der niemals einen Selektor hardcodiert.

if __name__ == "__main__":
    html = fetch_html(target_url)
    text = to_text(html)
    data = extract(text, ["product_name", "price", "rating", "in_stock"])
    print(json.dumps(data, indent=2))

Das Ergebnis ist strukturiert und bereit zur Speicherung.

{
  "product_name": "Acme Widget Pro",
  "price": "$49.99",
  "rating": "4.6",
  "in_stock": true
}

Prompts entwerfen, die zuverlässig extrahieren

Der Prompt ist jetzt der Ort, an dem Ihre Scraping-Logik lebt, also lohnt es sich, ihn bewusst zu schreiben. Ein paar Muster machen den Unterschied zwischen unzuverlässiger Ausgabe und Daten, denen man vertrauen kann.

Ein explizites Schema definieren, keine vage Anfrage

"Hol die wichtigen Infos" lässt dem Modell Raum zum Raten. Benennen Sie jedes Feld, seinen Typ und was zu tun ist, wenn es fehlt. Ein JSON-Skelett im Prompt zu übergeben ist sogar stärker, weil das Modell eine Form ausfüllt, die es sehen kann, statt eine, die es ableiten muss.

schema = {
    "product_name": "string",
    "price": "string, include currency symbol",
    "rating": "number or null",
    "specs": "object of key-value pairs",
}

prompt = (
    f"Fill this schema from the page content. "
    f"Use null for anything absent.\n\n"
    f"Schema:\n{json.dumps(schema, indent=2)}\n\n"
    f"Content:\n{content}"
)

Formate festlegen und Erfindungen verbieten

Geben Sie genau an, wie jeder Wert aussehen soll: das Währungssymbol bei Preisen behalten, Daten auf YYYY-MM-DD normalisieren, Bewertungen als Zahlen zurückgeben. Ebenso wichtig: dem Modell sagen, niemals zu raten. Die Anweisung "null für fehlende Felder verwenden, niemals erfinden" im System-Prompt ist das, was halluzinierte Werte verhindert, das größte einzelne Risiko bei modellbasierter Extraktion.

Temperatur senken und Ausgabe validieren

Setzen Sie temperature=0, damit dieselbe Seite dasselbe JSON ergibt. Validieren Sie dann, was zurückkommt: bestätigen Sie, dass es parsierbar ist, prüfen Sie, dass erforderliche Keys existieren, und verifizieren Sie Typen. Das Modell gibt Text zurück, also behandeln Sie seine Ausgabe als nicht vertrauenswürdige Eingabe, bis Ihr Code sie geprüft hat, genau wie bei jeder externen Quelle.

Große Seiten behandeln, die das Kontextfenster überschreiten

Das obige Muster funktioniert, bis eine Seite zu groß ist, um in einen Modellaufruf zu passen. Lange Kategorie-Listings, Hunderte von Bewertungseinträgen und dichte Dokumentationen können das Kontextfenster sprengen oder pro Anfrage schlicht zu teuer werden. Die Lösung besteht darin, den Inhalt in Chunks zu teilen, aus jedem zu extrahieren und die Ergebnisse zusammenzuführen.

def chunk_text(text, size=12000, overlap=500):
    chunks = []
    start = 0
    while start < len(text):
        end = start + size
        chunks.append(text[start:end])
        start = end - overlap
    return chunks

def extract_large(text, fields):
    results = []
    for chunk in chunk_text(text):
        part = extract(chunk, fields)
        if part:
            results.append(part)
    return results

Einige Regeln halten Chunking ehrlich. Überlappen Sie die Chunks um einige hundert Zeichen, damit ein Datensatz, der eine Grenze überspannt, nicht in der Mitte zerschnitten wird. Teilen Sie nach Möglichkeit an natürlichen Grenzen wie Absätzen oder Listenelementen und nicht mitten in einem Wort. Für Listenseiten bitten Sie jeden Chunk um ein Array von Elementen und verketten die Arrays, dann deduplizieren Sie auf einem stabilen Key wie einer Produkt-ID oder URL, da der Überlapp einige Duplikate erzeugt. Das Muster ist dasselbe, das Produktionssysteme verwenden, und die grundlegenden Mechaniken werden in Wie KI-Datenextraktion funktioniert erklärt.

Wenn die Seite zurückschlägt

Alles bisher setzt voraus, dass der Abruf erfolgreich ist. Bei gut gesicherten Sites wird er es nicht sein, zumindest nicht lange. Die Crawling API übernimmt Rendering und IP-Rotation im bereits geschriebenen Aufruf, was die meisten Blocks beseitigt. Wenn Sie mit höherem Volumen arbeiten oder ungewöhnlich aggressiven Zielen begegnen, leiten Sie durch den Smart AI Proxy, der seine Strategie pro Ziel anpasst, um die Erfolgsraten hoch zu halten, oder greifen Sie auf die Crawling API zurück, wenn eine Site bereits einen gepflegten Parser hat und Sie saubere Felder ohne LLM-Aufruf möchten.

Die Arbeitsteilung ist das Entscheidende: Crawlbase ist dafür verantwortlich, Abwehrmechanismen zu überwinden und eine echte Seite zu liefern, und das OpenAI-Modell ist dafür verantwortlich, sie zu lesen. Beides zu vermischen, indem man ChatGPT bittet, eine URL abzurufen, führt zu geblockten Anfragen und halluzinierten Antworten. Halten Sie sie getrennt, und jedes tut den Teil, für den es gut ist. Wenn Sie Modellfamilien für die Extraktionshälfte vergleichen möchten, folgt unser Walkthrough zum Einsatz von Gemini AI für Web Scraping derselben Abruf-dann-Extrahieren-Form.

Häufig gestellte Fragen

Kann ChatGPT eine Website direkt scrapen?

Nein. ChatGPT hat keine zuverlässige Möglichkeit, eine Live-Seite abzurufen: Es wird wie jeder andere Client geblockt und erfindet oft eine Antwort, wenn es die URL nicht laden kann. Was es gut kann, ist Inhalte lesen, die man ihm gibt, und strukturierte Daten zurückgeben. Also ruft man die Seite mit einem Tool wie der Crawling API ab und übergibt dann das saubere HTML oder Markdown an das Modell zur Extraktion.

Warum mit Crawlbase statt Python requests abrufen?

Weil eine einfache Anfrage bei JavaScript-lastigen Sites eine leere Hülle zurückgibt und bei gesicherten Sites geblockt wird. Die Crawling API rendert die Seite in einem echten Browser und leitet durch rotierende residential IPs, sodass der Inhalt, den das Modell sieht, derselbe ist, den ein Mensch sehen würde. Ohne diesen Schritt extrahiert das Modell aus einer leeren Seite oder einer Bot-Detection-Seite.

Welches OpenAI-Modell sollte ich für die Extraktion verwenden?

Ein kleines, schnelles Modell wie gpt-4o-mini bewältigt die meiste Feldextraktion gut und hält die Kosten bei großem Maßstab niedrig. Greifen Sie nur dann auf ein größeres Modell zurück, wenn die Seite echtes Reasoning erfordert, zum Beispiel das Ableiten von Feldern, die impliziert statt angegeben sind, oder das Abgleichen widersprüchlicher Werte. Klein anfangen, Genauigkeit auf eigenen Seiten messen und nur dann skalieren, wenn das kleine Modell Fehler macht.

Wie verhindere ich, dass das Modell Werte halluziniert?

Drei Dinge zusammen. temperature=0 für deterministische Ausgabe setzen, das Modell im System-Prompt anweisen, null für fehlende Felder zu verwenden und niemals Daten zu erfinden, und das zurückgegebene JSON im Code validieren. Das Bitten, Werte wörtlich aus dem Text zu kopieren statt zusammenzufassen, reduziert ebenfalls erfundene Antworten.

Wie gehe ich mit einer Seite um, die zu groß für eine Anfrage ist?

Den bereinigten Inhalt in überlappende Chunks teilen, aus jedem Chunk separat extrahieren und die Ergebnisse zusammenführen. Bei Listenseiten ein Array pro Chunk zurückgeben und auf einem stabilen Key wie einer Produkt-ID deduplizieren, da der Überlapp einige Duplikate erzeugt. Das Reduzieren des HTML auf Text schrumpft die Seite oft genug, damit viele "zu große" Seiten in einen einzigen Aufruf passen.

Ist ChatGPT Web Scraping legal?

Es kommt auf die Nutzungsbedingungen der Zielsite, Ihre Rechtsprechung und das Verwendungszweck der Daten an. Bleiben Sie strikt bei öffentlichen Inhalten, respektieren Sie robots.txt und Erwartungen zur Anfragerate, und berühren Sie niemals Konten, persönliche Daten oder irgendetwas hinter einem Login. Für kommerzielle Weiterverwendung holen Sie sich Erlaubnis oder eine offizielle Datenvereinbarung, anstatt sich auf einen Scraper zu verlassen.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.