Wichtige Python-Bibliotheken für Web Scraping: Ein Starter-Toolkit

Python ist die Standardsprache für Web Scraping, und das aus gutem Grund. Es gibt eine kleine Auswahl ausgereifter Bibliotheken, die jeden Schritt der Arbeit abdecken: Seiten abrufen, HTML parsen, einen echten Browser steuern und die extrahierten Daten bereinigen. Das Schwierige am Anfang ist nicht das Schreiben von Code. Es ist zu wissen, welche Bibliothek man wann einsetzt und warum.

Dieser Leitfaden geht die Bibliotheken durch, die zählen, was jede gut kann und wie du sie zu einem Stack kombinierst, auf dem du aufbauen kannst.

Wie man an einen Scraping-Stack herangeht

Jede Scraping-Aufgabe zerfällt in drei Schritte:

1. Abrufen der Seite (das rohe HTML oder JSON vom Server holen).
2. Parsen des Inhalts (die gewünschten Werte im Markup finden).
3. Speichern des Ergebnisses (in CSV, JSON oder eine Datenbank schreiben).

Manche Seiten brauchen einen vierten Schritt: Rendern. Wenn die Daten erst nach dem Ausführen von JavaScript erscheinen, liefert eine einfache HTTP-Anfrage nur eine leere Hülle, und du brauchst einen Browser, der die Seite zuerst ausführt.

Du brauchst nicht alle Bibliotheken unten am ersten Tag. Wähle ein Werkzeug pro Schritt, bring einen funktionierenden Scraper zum Laufen und füge weitere erst hinzu, wenn eine Seite dich dazu zwingt.

Seiten abrufen: HTTP-Clients

requests

requests ist die Bibliothek, mit der die meisten anfangen. Sie sendet HTTP-Anfragen mit einer sauberen, gut lesbaren API und übernimmt Sessions, Header, Cookies und Weiterleitungen für dich.

import requests

resp = requests.get("https://example.com", timeout=10)
print(resp.status_code)
print(resp.text[:500])

Sie ist synchron, das heißt, sie ruft eine Seite nach der anderen ab. Für kleine Aufgaben und zum Lernen ist das in Ordnung. Wenn du Tausende Seiten scrapen musst, wird das Eine-nach-der-anderen-Modell zum Engpass.

httpx

httpx ist eine moderne Alternative mit fast derselben API wie requests, plus zwei Dingen, die requests fehlen: asynchrone Unterstützung und HTTP/2. Async lässt dich viele Anfragen gleichzeitig absetzen, ohne Threads, was bei I/O-lastiger Arbeit wie Scraping ein großer Geschwindigkeitsgewinn ist.

import httpx
import asyncio

async def fetch(url, client):
    resp = await client.get(url, timeout=10)
    return resp.status_code

async def main():
    urls = ["https://example.com"] * 20
    async with httpx.AsyncClient(http2=True) as client:
        results = await asyncio.gather(*(fetch(u, client) for u in urls))
    print(results)

asyncio.run(main())

Wenn du Anfänger bist, beginne mit requests. Wenn Geschwindigkeit zählt, wechsle zu httpx.

curl_cffi

Manche Seiten blockieren Anfragen anhand ihres TLS-Fingerabdrucks, der Signatur, die ein Client beim HTTPS-Handshake hinterlässt. Standard-Python-Clients haben einen Fingerabdruck, den Anti-Bot-Systeme sofort erkennen. curl_cffi kann den Fingerabdruck eines echten Chrome- oder Safari-Browsers nachahmen, was dich an einer überraschenden Zahl leichter Sperren vorbeibringt.

from curl_cffi import requests

resp = requests.get("https://example.com", impersonate="chrome")
print(resp.status_code)

Halte diese in der Hinterhand. Für freundliche Seiten brauchst du sie nicht, aber sie ist das Erste, was du versuchen solltest, wenn eine normale Anfrage einen 403 bekommt.

HTML parsen

BeautifulSoup

Sobald du das HTML hast, musst du Werte daraus ziehen. BeautifulSoup ist der zugänglichste Parser in Python. Du durchsuchst das Dokument nach Tag, Klasse oder CSS-Selektor, und er gibt die passenden Elemente zurück.

from bs4 import BeautifulSoup

html = "<div class='price'>$29.99</div>"
soup = BeautifulSoup(html, "html.parser")
print(soup.select_one(".price").text)  # $29.99

Er ist tolerant gegenüber fehlerhaftem Markup und leicht zu lesen, weshalb er der übliche erste Parser zum Lernen ist.

lxml und parsel

lxml ist schneller als BeautifulSoup und unterstützt XPath, eine Abfragesprache, die bei tief verschachtelten Dokumenten präziser ist. parsel (der Parser, den Scrapy intern nutzt) umhüllt lxml mit einer sauberen API und funktioniert gut als eigenständiges Werkzeug.

from parsel import Selector

sel = Selector(text="<div class='price'>$29.99</div>")
print(sel.css(".price::text").get())        # CSS-Selektor
print(sel.xpath("//div[@class='price']/text()").get())  # XPath

Lerne zuerst CSS-Selektoren. Greife zu XPath, wenn du nach Textinhalt filtern oder zu einem Elternelement navigieren musst, was CSS nicht kann.

Vollständige Frameworks: Scrapy

Scrapy ist keine einzelne Bibliothek, es ist ein komplettes Framework. Es kümmert sich von Haus aus um Anfragen, Parsen, Nebenläufigkeit, Wiederholungen, Ratenbegrenzung und Datenexport. Für ein einmaliges Skript ist es überdimensioniert. Für einen echten Crawler, der Tausende Seiten besucht und Links folgt, erspart es dir, viel Infrastruktur neu zu erfinden.

import scrapy

class QuotesSpider(scrapy.Spider):
    name = "quotes"
    start_urls = ["https://quotes.toscrape.com"]

    def parse(self, response):
        for quote in response.css("div.quote"):
            yield {
                "text": quote.css("span.text::text").get(),
                "author": quote.css("small.author::text").get(),
            }
        next_page = response.css("li.next a::attr(href)").get()
        if next_page:
            yield response.follow(next_page, self.parse)

Scrapy hat eine Lernkurve, daher ist es nicht der Ort, an dem Anfänger starten sollten. Aber sobald du einzelnen Skripten entwachsen bist, ist es der natürliche nächste Schritt.

Browser-Automatisierung für JavaScript-Seiten

Wenn Inhalt per JavaScript geladen wird, liefern HTTP-Clients eine leere Seite. Du brauchst einen echten Browser.

Selenium

Selenium ist der Veteran der Browser-Automatisierung. Es steuert Chrome, Firefox und andere über deren offizielle Treiber. Es ist umfassend dokumentiert und funktioniert überall, ist aber langsamer und schwergewichtiger als neuere Werkzeuge.

Playwright

Playwright ist die moderne Wahl. Es ist schneller, hat eine sauberere API, wartet automatisch auf Elemente und bringt Browser-Binaries mit, sodass die Einrichtung mühelos ist. Es unterstützt auch async von Haus aus.

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

Faustregel: Probiere zuerst einen HTTP-Client. Browser verbrauchen weit mehr CPU und Speicher, also greife nur dann zu einem, wenn die Daten wirklich JavaScript zum Erscheinen brauchen.

Daten bereinigen und speichern

Sobald du Werte extrahiert hast, ist pandas das Standardwerkzeug, um sie in Form zu bringen. Lade deine gescrapten Zeilen in einen DataFrame, entferne Duplikate, korrigiere Typen und exportiere mit einer Zeile nach CSV, Excel oder in eine Datenbank.

import pandas as pd

df = pd.DataFrame(rows)
df.drop_duplicates().to_csv("output.csv", index=False)

Für einfache Aufgaben reichen Pythons eingebaute Module csv und json und fügen keine Abhängigkeiten hinzu.

Ein empfohlener Starter-Stack

Wenn du einen einzigen Stack zuerst lernen willst, nimm diesen:

• requests zum Abrufen von Seiten
• BeautifulSoup zum Parsen von HTML
• pandas zum Bereinigen und Exportieren

Diese Kombination bewältigt die meisten statischen Seiten. Füge httpx hinzu, wenn du Geschwindigkeit brauchst, playwright, wenn du JavaScript brauchst, und curl_cffi, wenn du auf Sperren stößt.

Wenn Seiten sich wehren

Die obigen Bibliotheken reichen für einfache, kooperative Seiten. In dem Moment, in dem du im großen Maßstab scrapest oder eine Seite mit Anti-Bot-Schutz ins Visier nimmst, triffst du auf Sperren, CAPTCHAs, Ratenbegrenzungen und Seiten, die einen Status 200 zurückgeben, aber keinen echten Inhalt. Proxies zu rotieren, Browser-Fingerabdrücke zu verwalten und Challenges selbst zu lösen, ist für sich genommen ein großes, dauerhaftes Projekt.

Das ist die Lücke, die ScrapeUnblocker füllt, und es bringt eine offizielle Python-Bibliothek mit, damit du deine Arbeitsweise nicht ändern musst. Installiere sie, und ein Aufruf liefert das vollständig entsperrte HTML, mit Proxy-Rotation, Browser-Rendering und Anti-Bot-Handhabung für dich erledigt:

pip install scrapeunblocker

from scrapeunblocker import Client

su = Client(api_key="YOUR_API_KEY")

# Vollständig gerendertes, entsperrtes HTML - direkt an BeautifulSoup weiterreichen
html = su.get_page_source("https://example.com")

# Oder direkt geparste, strukturierte Daten holen
result = su.get_parsed("https://www.amazon.com/dp/B08N5WRWNW")
print(result.data["title"], result.data["price"])

Du behältst deine bevorzugten Parsing-Werkzeuge. Der Abrufschritt hört einfach auf zu scheitern. Siehe die Entwicklerdokumentation für die komplette API.

FAQ

Welche Python-Bibliothek sollte ein Anfänger zuerst lernen? Beginne mit requests zum Abrufen und BeautifulSoup zum Parsen. Sie haben die sanfteste Lernkurve und decken die meisten statischen Websites ab. Füge weitere Werkzeuge erst hinzu, wenn eine bestimmte Seite dich dazu zwingt.

Brauche ich Scrapy oder Playwright zum Einstieg? Nein. Scrapy lohnt sich, sobald du Tausende Seiten crawlst und Links folgst. Playwright wird nur gebraucht, wenn Inhalt per JavaScript geladen wird. Beide sind nächste Schritte, keine Startpunkte.

Warum bekommt mein Scraper eine leere Seite, obwohl die Seite in meinem Browser funktioniert? Die Seite rendert den Inhalt fast sicher per JavaScript. Eine einfache HTTP-Anfrage bekommt nur das anfängliche HTML, bevor die Skripte laufen. Nutze Playwright oder Selenium, um die Seite auszuführen, oder einen Dienst, der sie für dich rendert.

Wie vermeide ich, beim Scrapen blockiert zu werden? Halte Ratenbegrenzungen ein, setze einen realistischen User Agent und mach langsamer. Wenn eine Seite dich aktiv blockiert, brauchst du rotierende Proxies und Fingerabdruck-Handhabung. Werkzeuge wie curl_cffi helfen bei leichten Sperren, und ein Dienst wie ScrapeUnblocker bewältigt die harten Fälle von Anfang bis Ende.

Zum Abschluss

Du musst nicht alle Scraping-Bibliotheken auf einmal lernen. Werde vertraut mit einem Abruf-Werkzeug, einem Parser und einer Möglichkeit, Daten zu speichern, und erweitere dann dein Toolkit, wenn echte Seiten sich wehren. Fang klein an, bring einen funktionierenden Scraper an den Start und füge die schwereren Werkzeuge erst hinzu, wenn die Aufgabe es verlangt.