Perplexity AI Web Scraping in PythonAbrufen, dann interpretieren

Eine Webseite in saubere, strukturierte Daten zu verwandeln ist zwei Aufgaben, nicht eine. Zuerst müssen Sie die Seite abrufen, was trivial klingt, bis das Ziel Ihnen ein CAPTCHA oder eine leere Hülle liefert. Dann müssen Sie das Markup lesen und die Felder herausziehen, die Sie tatsächlich wollen, was traditionell bedeutet, brüchige Parser für jede Seite von Hand zu schreiben. Dieser Leitfaden kombiniert zwei Werkzeuge, die jeweils eine Hälfte übernehmen: Die Crawlbase Crawling API sammelt die Seite, und Perplexity AI interpretiert sie als JSON.

Das Ergebnis ist ein kleines, ausführbares Python-Skript für Perplexity AI Web Scraping in Python: Rufen Sie den HTML-Code über die Crawling API ab, kürzen Sie ihn auf den relevanten Teil, konvertieren Sie ihn zu Markdown, um Token zu sparen, und übergeben Sie ihn dann mit einem Prompt, der genau angibt, was extrahiert werden soll, an Perplexitys API. Das Wichtigste ist, die Arbeitsteilung klar zu halten. Perplexity crawlt die Seite in diesem Ablauf nicht. Es liest den Text, den Sie ihm geben. Das Abrufen, Rendern und Vermeiden von Blockierungen geschieht im Crawling-API-Schritt.

Warum Perplexity AI für Web Scraping verwenden

Klassisches Python-Scraping basiert auf requests und BeautifulSoup: Sie rufen das HTML ab und schreiben dann Selektoren, die den DOM zu den gewünschten Feldern durchlaufen. Das funktioniert gut auf ordentlichen, stabilen Seiten. Es bricht zusammen, wenn das Markup tief verschachtelt, über Listings inkonsistent oder alle paar Wochen umgeschrieben ist, weil jede Änderung das Umschreiben von Selektoren bedeutet.

Ein LLM wie Perplexity verändert die zweite Hälfte dieser Gleichung. Statt ihm zu sagen, wo der Preis im DOM sitzt, sagen Sie ihm, was Sie wollen ("den Produkttitel, den Preis und eine einzeilige Zusammenfassung"), und es liest den Inhalt so, wie ein Mensch es tun würde. Es ist gut darin, Struktur aus unübersichtlichem Text herauszuziehen und als JSON zurückzugeben, was genau die Form ist, die Sie für eine Pipeline brauchen. Das ist dieselbe Idee hinter KI-Datenextraktion im Allgemeinen, und Perplexitys Sonar-Modelle fügen obendrauf Web-Verankerung hinzu.

Was Perplexity hier tut und was nicht

Perplexitys API ist OpenAI-kompatibel, sodass Sie mit demselben openai-Client und einer anderen Basis-URL mit ihr kommunizieren. In diesem Scraper übernimmt sie genau eine Rolle: den gesammelten Seitentext lesen und strukturierte Felder zurückgeben. Es ist nicht Ihr Crawler, es vermeidet keine Blockierungen und ist kein Proxy. Halten Sie diese Grenze klar, und die Architektur bleibt einfach: Crawlbase holt die Bytes, Perplexity macht Sinn daraus.

Python-Umgebung einrichten

Sie brauchen Python 3.8 oder neuer. Erstellen Sie eine virtuelle Umgebung, damit die Abhängigkeiten dieses Projekts isoliert bleiben, und aktivieren Sie sie dann.

python -m venv perplexity_env

# Windows
perplexity_env\Scripts\activate

# macOS / Linux
source perplexity_env/bin/activate

Installieren Sie nun die vier Bibliotheken, die das Skript verwendet.

pip install crawlbase beautifulsoup4 markdownify openai

• crawlbase der Client für die Crawling API, der die Seite abruft und rendert.
• beautifulsoup4 kürzt das HTML auf den relevanten Abschnitt, bevor Sie Token dafür aufwenden.
• markdownify konvertiert diesen Abschnitt zu Markdown, damit das Modell sauberen Text statt Tag-Suppe erhält.
• openai der OpenAI-kompatible Client, den Perplexitys API spricht.

Sie benötigen außerdem zwei Schlüssel. Holen Sie sich ein Crawlbase-Token vom Dashboard nach der Registrierung und einen Perplexity API-Schlüssel aus Ihren Perplexity-Kontoeinstellungen. Halten Sie beide aus der Quellcodeverwaltung heraus, in Umgebungsvariablen oder einer Secrets-Datei, und fügen Sie sie niemals in geteilten Code ein.

Schritt 1: Die Seite mit der Crawling API abrufen

Dies ist der Sammelschritt, und hier werden Blockierungen verarbeitet. Sie senden der Crawling API eine URL; sie leitet die Anfrage durch rotierende Residential-IPs, rendert optional JavaScript, verarbeitet die CAPTCHAs und Challenges, die ein einfaches requests.get stoppen würden, und gibt das fertige HTML zurück. Sie müssen sich niemals selbst mit einem Proxy-Pool oder einem Headless-Browser befassen.

Speichern Sie dies als crawl.py. Wir verwenden eine Amazon-Produktseite als Beispielziel.

from crawlbase import CrawlingAPI

api = CrawlingAPI({'token': 'YOUR_CRAWLBASE_JS_TOKEN'})

def crawl(url: str) -> str:
    response = api.get(url, {'ajax_wait': 'true', 'page_wait': 3000})
    if response['status_code'] != 200:
        raise RuntimeError(f'Crawl failed: {response["status_code"]}')
    return response['body'].decode('utf-8')

if __name__ == '__main__':
    url = 'https://www.amazon.com/Art-War-DELUXE-Sun-Tzu/dp/9388369696'
    html = crawl(url)
    with open('output.html', 'w', encoding='utf-8') as f:
        f.write(html)
    print('Saved output.html')

Führen Sie es mit python crawl.py aus. Sie erhalten eine output.html mit dem echten Produkt-Markup darin, nicht die blockierte oder leere Seite, die eine direkte Anfrage oft zurückgibt. Die Optionen ajax_wait und page_wait weisen den Renderer an, auf asynchronen Inhalt zu warten; erhöhen Sie page_wait, wenn die Ergebnisse dünn zurückkommen. Das ist der gesamte Sinn der Verwendung der Crawling API hier: Sie ist die Schicht, die Ihnen überhaupt erst eine verwendbare Seite verschafft, was auch den KI-Schritt erst möglich macht.

Schritt 2: Das HTML kürzen und zu Markdown konvertieren

Eine vollständige Produktseite besteht aus Hunderten von Kilobytes an Navigationsleisten, Skripten und Fußzeilen. All das an Perplexity zu senden ist langsam und verschwenderisch, da LLM-Preise pro Token berechnet werden und die meisten dieser Token Lärm sind. Zwei günstige Schritte beheben das: Verwenden Sie BeautifulSoup, um nur den Abschnitt zu nehmen, der Sie interessiert, und konvertieren Sie diesen Abschnitt dann zu Markdown, damit das Modell saubere Prosa statt Tags liest.

Speichern Sie dies als parse.py.

from bs4 import BeautifulSoup
from markdownify import markdownify as md

def html_to_markdown(html: str) -> str:
    soup = BeautifulSoup(html, 'html.parser')
    element = soup.find(id='centerCol') or soup.body
    if element is None:
        raise ValueError('Could not find content section in HTML')
    return md(str(element))

Die centerCol-ID ist die Hauptproduktspalte auf dieser Amazon-Seite; für eine andere Seite inspizieren Sie die Live-Seite in den Entwicklertools Ihres Browsers und zielen auf den Container, der die gewünschten Felder enthält. Das Fallback or soup.body verhindert, dass das Skript abstürzt, wenn diese ID fehlt. Selektoren driften im Laufe der Zeit, behandeln Sie den Zielcontainer also als etwas, das Sie erneut prüfen werden, nicht als dauerhaften Vertrag.

Schritt 3: Den Extraktions-Prompt schreiben

Im Prompt teilen Sie Perplexity mit, was es extrahieren und wie es formen soll. Seien Sie spezifisch bei den Feldern und fordern Sie ausschließlich JSON an, damit die Antwort leicht downstream zu parsen ist. Eine Systemnachricht setzt die Rolle; die Benutzernachricht enthält die Anweisungen plus das Markdown.

def build_prompt(markdown: str) -> list:
    return [
        {
            'role': 'system',
            'content': 'You extract structured data from product pages. Reply with JSON only, no prose.',
        },
        {
            'role': 'user',
            'content': (
                'Extract these fields from the Markdown:\n'
                '- title\n'
                '- price\n'
                '- rating\n'
                '- one_sentence_summary\n\n'
                f'Markdown:\n{markdown}\n\n'
                'Respond with a single JSON object.'
            ),
        },
    ]

Klare Feldnamen und eine explizite "nur JSON"-Anweisung erledigen den Großteil der Arbeit. Wenn Sie eine strenge Form benötigen, benennen Sie jeden erwarteten Schlüssel, und das Modell wird ihn genau einhalten.

Schritt 4: Perplexity aufrufen und den Scraper zusammenbauen

Jetzt verbinden Sie alles. Der openai-Client zeigt auf https://api.perplexity.ai, Sie senden den Prompt an ein Sonar-Modell und parsen das zurückgegebene JSON. Speichern Sie dies als scraper.py.

import json
from openai import OpenAI
from crawl import crawl
from parse import html_to_markdown
from build_prompt import build_prompt

URL = 'https://www.amazon.com/Art-War-DELUXE-Sun-Tzu/dp/9388369696'

client = OpenAI(
    api_key='YOUR_PERPLEXITY_API_KEY',
    base_url='https://api.perplexity.ai',
)

def scrape(url: str) -> dict:
    html = crawl(url)
    markdown = html_to_markdown(html)
    messages = build_prompt(markdown)

    response = client.chat.completions.create(
        model='sonar-pro',
        messages=messages,
    )
    content = response.choices[0].message.content
    return json.loads(content)

if __name__ == '__main__':
    data = scrape(URL)
    print(json.dumps(data, indent=2))

Führen Sie es mit python scraper.py aus, nachdem Sie Ihre zwei Schlüssel eingetragen haben. Das Modell sonar-pro ist Perplexitys stärkeres Sonar-Tier; sonar ist günstiger und für einfache Extraktion ausreichend. Beide sprechen das OpenAI Chat-Completions-Format, sodass das Wechseln von Modellen eine einzeilige Änderung ist.

Wie die Ausgabe aussieht

Das Ergebnis ist ein sauberes JSON-Objekt, das Sie in eine Datenbank, eine CSV oder die nächste Stufe einer Pipeline schreiben können.

{
  "title": "The Art of War (Deluxe Hardbound Edition)",
  "price": "$15.80",
  "rating": "4.7 out of 5",
  "one_sentence_summary": "An ancient Chinese treatise by Sun Tzu on strategy, planning, and adapting tactics to win conflicts."
}

Beachten Sie eine Besonderheit, die in der Produktion behandelt werden sollte: Perplexitys Sonar-Modelle sind web-verankert und hängen manchmal Zitationsmarker wie [1] an Text an oder wickeln JSON in einen Code-Zaun. Wenn json.loads einen Fehler wirft, entfernen Sie einen führenden und abschließenden Zaun vor dem Parsen oder weisen Sie das Modell deutlicher an, rohes JSON zurückzugeben. Ein kurzer Bereinigungsschritt hält den Parser zuverlässig.

Herausforderungen und Grenzen, die zu beachten sind

Ein LLM mit einem Crawler zu kombinieren ist leistungsstark, aber nicht ohne Kompromisse. Die Kosten skalieren mit Token, sodass der Schritt zum Kürzen zu Markdown wichtiger wird, wenn Sie skalieren; senden Sie keine ganzen Seiten. Die Latenz ist höher als bei einem handgeschriebenen Parser, da Sie auf einen Modell-Rundtrip pro Seite warten, was für Hunderte von Seiten in Ordnung ist und für Millionen überdacht werden sollte. Und LLMs können gelegentlich ein Feld falsch beschriften oder einen Wert halluzinieren, also validieren Sie kritische Felder (wandeln Sie Preise in Zahlen um, prüfen Sie erforderliche Schlüssel) statt der Ausgabe blind zu vertrauen.

Für sehr hoch volumige, fest strukturierte Aufgaben, bei denen Sie die genauen Felder bereits kennen, kann ein deterministischer Parser oder die eigene Crawling API von Crawlbase mit ihren vorgefertigten Parsern günstiger und schneller sein als ein LLM. Der KI-Ansatz verdient seinen Einsatz, wenn Seiten variiert, unübersichtlich oder häufig geändert sind. Wenn Sie KI-Anbieter für diese Art von Arbeit vergleichen möchten, geht Gemini AI für Web Scraping nutzen dasselbe Muster mit einem anderen Modell durch.

Den Sammelschritt unblockiert halten

Alles oben Genannte setzt voraus, dass Schritt 1 tatsächlich eine echte Seite zurückgibt. Bei harten kommerziellen Zielen ist diese Annahme der Punkt, an dem Scraper scheitern, sodass einige Gewohnheiten die Sammelschicht gesund halten.

• Verwenden Sie das JS-Token, wenn die Seite clientseitig gerendert wird. Das normale Token gibt auf diesen Seiten die Vorab-Render-Hülle zurück, und dann hat Perplexity nichts zu lesen.
• Auf Rotation setzen. Die Crawling API und der Smart AI Proxy leiten Anfragen durch rotierende Residential-IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Anfragen dosieren und Status-Codes lesen. Verteilen Sie Anfragen, variieren Sie Parameter und behandeln Sie eine steigende Rate von Challenges als Signal zum Zurückziehen, nicht zum Weiterschieben.

Für das vollständige Handbuch dazu, lesen Sie wie man Websites scrapet ohne blockiert zu werden. Kurz gesagt: Lassen Sie die Crawling API das Sammeln und Vermeiden von Blockierungen übernehmen, und lassen Sie Perplexity die Interpretation übernehmen. Halten Sie diese beiden Verantwortlichkeiten getrennt, und das System ist leicht nachzuvollziehen.

Häufig gestellte Fragen

Scrapt Perplexity AI die Website selbst?

Nein, nicht in diesem Workflow. Perplexity liest Text, den Sie ihm geben, und gibt strukturierte Daten zurück; es ruft die Zielseite nicht ab, rendert kein JavaScript und verarbeitet keine Blockierungen. Die Crawling API übernimmt die gesamte Sammlung, einschließlich Rotation der Residential-IPs und des Renderings, und dann übergeben Sie ihr HTML oder Markdown an Perplexity zur Interpretation. Diese Grenze klar zu halten ist der Schlüssel zum Verständnis der Architektur.

Warum das HTML zu Markdown konvertieren, bevor es an Perplexity gesendet wird?

Zwei Gründe: Kosten und Qualität. Eine vollständige HTML-Seite besteht größtenteils aus Navigation, Skripten und Styling, die Token verschwenden, und LLM-Preise werden pro Token berechnet. Den relevanten Abschnitt mit BeautifulSoup kürzen und zu Markdown konvertieren gibt dem Modell saubere Prosa zu lesen, was sowohl die Kosten senkt als auch die Extraktionsgenauigkeit verbessert, weil weniger Rauschen zu durchdringen ist.

Welches Perplexity-Modell sollte ich verwenden, sonar oder sonar-pro?

Beginnen Sie mit sonar für einfache, gut strukturierte Seiten; es ist günstiger und meistens genau genug. Wechseln Sie zu sonar-pro, wenn die Extraktionsqualität wichtig ist oder der Inhalt dicht und vielfältig ist. Beide verwenden das OpenAI-kompatible Chat-Completions-Format, sodass das Wechseln eine einzeilige Änderung am Argument model ist.

Brauche ich das normale Crawlbase-Token oder das JS-Token?

Es hängt vom Ziel ab. Verwenden Sie das normale Token für server-gerenderte Seiten, bei denen das HTML bereits die Daten enthält. Verwenden Sie das JS-Token, wenn die Seite ihren Inhalt clientseitig aufbaut, was bei den meisten modernen Shops und Apps der Fall ist, weil das normale Token die leere Vorab-Render-Hülle zurückgeben würde und Perplexity nichts zum Extrahieren hätte.

Das JSON-Parsen schlägt immer wieder fehl. Was ist das Problem?

Perplexitys Sonar-Modelle sind web-verankert und können die Ausgabe in einen Code-Zaun einwickeln oder Zitationsmarker wie [1] anhängen, was json.loads zum Scheitern bringt. Entfernen Sie jeden führenden und abschließenden Zaun vor dem Parsen, verschärfen Sie den Prompt, um auf reines JSON ohne zusätzlichen Text zu bestehen, und validieren Sie das geparste Objekt, bevor Sie es verwenden. Ein kleiner Bereinigungsschritt macht die Pipeline zuverlässig.

Kann ich Perplexity AI und Crawlbase zusammen im großen Maßstab verwenden?

Ja, und sie ergänzen sich gut. Crawlbase übernimmt das Sammeln und Vermeiden von Blockierungen, damit Ihre Anfragen ankommen, und Perplexity wandelt jede Seite in strukturierte Daten um. Für sehr hohes Volumen mit einem festen Schema wägen Sie die LLM-Kosten pro Seite gegen einen deterministischen Parser oder die Scraper API ab; der KI-Ansatz glänzt, wenn Seiten unübersichtlich oder häufig geändert sind, während Aufgaben mit festem Schema möglicherweise günstiger ohne LLM sind.

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.