Wie man einen Web Scraper mit Pyppeteer erstellt (2026 Anleitung)

Kurz gesagt: Pyppeteer ist die inoffizielle Python-Portierung von Puppeteer und eignet sich nach wie vor zur Steuerung eines echten Chromium-Browsers asyncio. In dieser Anleitung installierst du es und schreibst einen modernen Web-Scraper mit Pyppeteer unter Verwendung von asyncio.run und try/finally, lernen, wie man Wartezeiten, Formulare, Screenshots, Infinite Scroll, Cookies und Proxys handhabt, und erfahren, wann man zu Playwright, Selenium oder einer gehosteten Scraping-API wechseln sollte.

Wenn du requests plus BeautifulSoup entwachsen sind, weil die benötigten Daten erst nach der Ausführung von JavaScript erscheinen, haben Sie sich wahrscheinlich bereits mit der Erstellung eines Web-Scrapers mit Pyppeteer beschäftigt. Pyppeteer ist die Python-Portierung von Puppeteer und ermöglicht es Ihnen, eine echte Chromium-Instanz zu starten, auf Selektoren zu warten, auf Schaltflächen zu klicken und beliebiges JavaScript innerhalb der Seite aus async Python-Code ausführen. Das reicht aus, um Single-Page-Apps, Feeds mit unendlichem Bildlauf, Such-UIs und alles andere zu scrapen, was sich hinter einem fetch Aufruf verbirgt.

Dieser Leitfaden richtet sich an fortgeschrittene Python-Entwickler im Jahr 2026. Wir behandeln eine ehrliche Bestandsaufnahme des Projekts, einen Vergleich mit Selenium, Playwright und Node Puppeteer, moderne asynchrone Muster (asyncio.run, try/finally, strukturierte Wartezeiten) sowie ein vollständiges End-to-End-Beispiel, das mehrere Suchbegriffe in einer JavaScript-gesteuerten Such-Benutzeroberfläche durchläuft. Am Ende verfügen Sie über eine funktionierende Pyppeteer-Scraper-Vorlage sowie ein klares Entscheidungsraster dafür, wann Pyppeteer das richtige Werkzeug ist und wann nicht.

Pyppeteer im Jahr 2026: Wo es passt und was sich geändert hat

Pyppeteer ist im Kern ein Python-Wrapper, der die API von Puppeteer widerspiegelt: launch einen Browser, öffne eine page, aufrufen waitForSelector, ausführen evaluate, wiederholen. Das mentale Modell entspricht eins zu eins dem ursprünglichen Puppeteer-Projekt auf GitHub, was hilfreich ist, wenn man schon einmal ein Node-Tutorial gelesen hat und bei Python bleiben wollte.

Der ehrliche Vorbehalt für 2026 ist, dass Pyppeteer nur minimal gepflegt wird. Die Betreuer geben im README des Projekts an, dass es nur minimal gepflegt wird, und mehrere neuere Puppeteer-Funktionen wurden nie portiert. Das bedeutet nicht, dass Ihr Scraper morgen nicht mehr funktionieren wird, aber es bedeutet, dass Sie Pyppeteer nicht für ein langfristig betriebenes Produktionssystem wählen sollten, ohne Playwright und eine verwaltete Scraping-API als Alternativen abzuwägen. Wir werden am Ende auf diese Entscheidung zurückkommen.

Pyppeteer vs. Selenium, Playwright und Puppeteer

Bevor Sie sich festlegen, ist es hilfreich, Pyppeteer neben seinen engsten Alternativen zu betrachten. Die folgende Tabelle ist eine kurze Übersicht, damit Sie das richtige Tool für Ihren Stack auswählen können, anstatt sich einfach für das zu entscheiden, was bei Google als Erstes angezeigt wird.

Tool	Sprache	Asynchrones Modell	Browser	Stealth-Optionen	Wartung
Pyppeteer	Python	Nativ `asyncio`	Chromium	Manuell, kein natives Plugin	Nur in geringem Umfang gepflegt
Playwright (Python)	Python	Sync + `asyncio`	Chromium, Firefox, WebKit	Integrierte, für Stealth-Betrieb geeignete Standardeinstellungen	Aktiv von Microsoft entwickelt
Selenium	Python (und andere)	Synchron (asynchron über Wrapper)	Chromium, Firefox, Edge, Safari	`selenium-stealth`, unentdeckte Treiber	Aktiv gepflegt, ausgereift
Puppeteer (Node)	JavaScript / TypeScript	Native Promises	Chromium, Firefox (experimentell)	`puppeteer-extra-plugin-stealth`	Wird aktiv vom Chrome-Team entwickelt

Praktischer Tipp: Wählen Sie Puppeteer in Node, wenn Sie die neuesten Funktionen wünschen, Playwright für neue Python-Projekte, die stabiles browserübergreifendes Scraping erfordern, Selenium, wenn Sie Safari oder ältere IE-ähnliche Abläufe unterstützen müssen, und Pyppeteer, wenn ein kleines Python-Skript oder eine bestehende Codebasis bereits asyncio. Einen umfassenderen Vergleich finden Sie in unseren Übersichten zu Python-Headless-Browser-Bibliotheken und Puppeteer-Alternativen.

Einrichtung von Pyppeteer (Python, Chromium und M1/M2-Korrekturen)

Verwenden Sie Python 3.10 oder neuer und eine virtuelle Umgebung. Mit „uv“ erfolgt die Installation mit einem einzigen Befehl:

uv init pyppeteer-demo && cd pyppeteer-demo
uv add pyppeteer
uv run pyppeteer-install   # downloads bundled Chromium

Wenn Sie lieber pip, tauschen Sie python -m venv .venv && pip install pyppeteer && pyppeteer-install. Beim ersten Start lädt Pyppeteer möglicherweise einen gebündelten Chromium-Build herunter (zum Zeitpunkt der Erstellung dieses Artikels etwa 150 MB; überprüfen Sie daher vor der Bereitstellung die aktuellen Release-Notes). Um diesen Download zu überspringen und das systemeigene Chromium zu verwenden, setzen Sie PYPPETEER_SKIP_CHROMIUM_DOWNLOAD=1 und übergeben Sie executablePath an launch:

# macOS:  /Applications/Google Chrome.app/Contents/MacOS/Google Chrome
# Linux:  /usr/bin/google-chrome
# Windows: C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe
await launch(executablePath='/usr/bin/google-chrome', headless=True)

M1/M2-Mac-Fallstrick: Pyppeteer kann auf arm64. Wenn Chromium sich weigert zu starten oder sofort abstürzt, führen Sie Ihr Terminal unter Rosetta erneut aus; die Installation wird dann in der Regel problemlos abgeschlossen.

Erstellen Sie einen minimalen Web-Scraper mit Pyppeteer: eine moderne Vorlage

Hier ist ein wiederverwendbarer Starter für einen Web-Scraper mit Pyppeteer, der asyncio.run, den Browser in try/finally, und übergibt das gerenderte HTML an BeautifulSoup. Wir werden quotes.toscrape.com/js/, eine Sandbox-Seite, die Zitate über JavaScript rendert, sodass einfache HTTP-Clients eine leere <body>.

import asyncio
from bs4 import BeautifulSoup
from pyppeteer import launch

URL = 'https://quotes.toscrape.com/js/'

async def scrape() -> list[dict]:
    browser = await launch(headless=True, args=['--no-sandbox'])
    try:
        page = await browser.newPage()
        await page.goto(URL, {'waitUntil': 'networkidle2'})
        await page.waitForSelector('.quote')
        html = await page.content()
        soup = BeautifulSoup(html, 'html.parser')
        return [
            {
                'text': q.select_one('.text').get_text(strip=True),
                'author': q.select_one('.author').get_text(strip=True),
            }
            for q in soup.select('.quote')
        ]
    finally:
        await browser.close()

if __name__ == '__main__':
    for row in asyncio.run(scrape()):
        print(row)

Drei Dinge sind hier wichtig. asyncio.run ersetzt das ältere get_event_loop().run_until_complete Muster, das in älteren Tutorials noch immer gezeigt wird. try/finally stellt sicher, dass Chromium geschlossen wird, selbst wenn dein Code einen Fehler auslöst. Und waitForSelector ist der explizite Synchronisationspunkt, kein fester sleep , der auf schnellen Seiten Zeit verschwendet und auf langsamen Seiten eine Zeitüberschreitung verursacht.

Auf Elemente richtig warten

Pyppeteer bietet mehrere Warteoptionen, und die Wahl ist entscheidend. waitFor() ist vage und fehleranfällig, da es darauf wartet, dass „etwas“ passiert, während waitForSelector() explizit ist und erst dann aufgelöst wird, wenn der Zielknoten im DOM vorhanden ist. Greifen Sie waitForNavigation nach einem Absenden und verwenden Sie waitUntil='networkidle2' , wenn die Seite Hintergrund- fetch aufruft. Als Fallback kannst du page.waitFor(5000) aufrufen, um fünf Sekunden zu warten, aber betrachten Sie jede zeitgesteuerte Wartezeit als letzten Ausweg, da sie die größte einzelne Ursache für unzuverlässige Scraper ist.

Klicken, Tippen und Absenden von Formularen

Für umfangreichere Interaktionen kombinieren Sie page.click, page.type (mit einer kleinen delay , um menschlicher zu wirken) und page.keyboard.press. Warten Sie nach dem Absenden eines Formulars parallel zum Klick auf die Navigation, damit die Änderung der URL nicht übersehen wird:

await page.type('input[name="q"]', 'pyppeteer', {'delay': 80})
await asyncio.gather(
    page.waitForNavigation({'waitUntil': 'networkidle2'}),
    page.keyboard.press('Enter'),
)

Dieses Muster eignet sich für Anmeldeformulare, Suchleisten und jede Benutzeroberfläche, bei der ein POST-Request eine Weiterleitung auslöst.

Screenshots und PDF-Exporte

page.screenshot() erfassen standardmäßig den sichtbaren Viewport. Übergeben Sie fullPage=True für Aufnahmen von oben nach unten und rufen Sie setViewport zuerst auf, wenn Sie eine bestimmte Auflösung wünschen. PDFs stammen von page.pdf() und funktionieren am besten auf Seiten mit sauberen Druckstilen:

await page.setViewport({'width': 1440, 'height': 900})
await page.screenshot({'path': 'page.png', 'fullPage': True})
await page.pdf({
    'path': 'page.pdf',
    'format': 'A4',
    'printBackground': True,
    'margin': {'top': '20mm', 'bottom': '20mm', 'left': '15mm', 'right': '15mm'},
})

Umgang mit unendlichem Scrollen und Lazy Loading

Seiten mit unendlichem Bildlauf rendern ihren nächsten Datenblock erst, wenn du den Bildbereich nach unten scrollst. Verwende page.evaluate , um eine kleine JS-Schleife auszuführen, die document.body.scrollHeight und stoppt, sobald der Datenfluss nicht mehr wächst:

await page.evaluate('''async () => {
  await new Promise(resolve => {
    let last = 0;
    const timer = setInterval(() => {
      window.scrollBy(0, 800);
      const h = document.body.scrollHeight;
      if (h === last) { clearInterval(timer); resolve(); }
      last = h;
    }, 400);
  });
}''')

Begrenzen Sie die Schleife mit einer maximalen Iterationsanzahl, falls der Feed tatsächlich endlos ist.

Verwaltung von Cookies, Sitzungen und User-Agents

Bei Seiten, auf denen eine Anmeldung erforderlich ist, melden Sie sich einmal an, speichern Sie die Cookies und verwenden Sie diese beim nächsten Durchlauf erneut, damit keine erneute Anmeldung erforderlich wird:

cookies = await page.cookies()          # save somewhere safe
await page.setCookie(*saved_cookies)    # restore later
await page.setUserAgent('Mozilla/5.0 ... Chrome/124 Safari/537.36')
await page.setViewport({'width': 1366, 'height': 768})

Koppeln setUserAgent mit einem passenden setViewport , damit der Geräte-Fingerabdruck intern konsistent bleibt. Ein Desktop-UA mit einem 320-Pixel-Viewport ist ein klassischer Hinweis für die Bot-Erkennung.

End-to-End-Web-Scraper mit Pyppeteer: Scraping einer JavaScript-gesteuerten Such-UI

Fassen wir alles zusammen. Das folgende Skript durchläuft mehrere Suchbegriffe, gibt jeden einzelnen in eine Suchleiste ein, die Ergebnisse clientseitig rendert, wartet auf das Erscheinen der Ergebniskarten, extrahiert deren Titel mit querySelectorAllEvalund löscht die Eingabe vor dem nächsten Schlüsselwort. Tauschen Sie die URL und die Selektoren aus, um sie an Ihr tatsächliches Ziel anzupassen.

import asyncio
from pyppeteer import launch

KEYWORDS = ['python', 'pyppeteer', 'asyncio']
SEARCH_URL = 'https://example.com/search'   # JS-rendered UI

async def search_one(page, keyword: str) -> list[str]:
    await page.click('input[name="q"]', {'clickCount': 3})
    await page.keyboard.press('Backspace')
    await page.type('input[name="q"]', keyword, {'delay': 60})
    await page.keyboard.press('Enter')
    await page.waitForSelector('.result-card', {'timeout': 10000})
    return await page.querySelectorAllEval(
        '.result-card h3',
        '(nodes) => nodes.map(n => n.innerText.trim())',
    )

async def main():
    browser = await launch(headless=True, args=['--no-sandbox'])
    try:
        page = await browser.newPage()
        await page.goto(SEARCH_URL, {'waitUntil': 'networkidle2'})
        results = {}
        for kw in KEYWORDS:
            results[kw] = await search_one(page, kw)
            await asyncio.sleep(2)   # be polite
        return results
    finally:
        await browser.close()

if __name__ == '__main__':
    print(asyncio.run(main()))

Dieses Muster ermöglicht zwei Verbesserungen. Erstens verwenden Sie einen Browser und eine Seite für alle Suchbegriffe, was die Ausführung kostengünstig hält. Zweitens macht das explizite waitForSelector macht den Scraper widerstandsfähig gegen Netzwerkjitter, sodass der Vorgang nicht zusammenbricht, sobald eine Anfrage 600 ms statt 200 ms dauert. Von hier aus ist das Einfügen von Wiederholungsversuchen und Parallelität mit asyncio.gather ein naheliegender nächster Schritt.

Verwendung von Proxys und Rotation mit Pyppeteer

Pyppeteer bewältigt die Browser-Automatisierung hervorragend, verwaltet Proxys jedoch nicht selbst, sodass Sie diese beim Start einbinden müssen. Das --proxy-server Chromium-Flag akzeptiert einen einzelnen Endpunkt, und page.authenticate fügt die Anmeldedaten vor der ersten Anfrage hinzu:

import random
from pyppeteer import launch

PROXIES = [
    'http://user:pass@proxy-a.example.com:8000',
    'http://user:pass@proxy-b.example.com:8000',
    'http://user:pass@proxy-c.example.com:8000',
]

async def launch_with_proxy():
    proxy = random.choice(PROXIES)   # naive rotation
    host = proxy.split('@')[-1]
    browser = await launch(args=[f'--proxy-server=http://{host}'])
    page = await browser.newPage()
    await page.authenticate({'username': 'user', 'password': 'pass'})
    return browser, page

Selbst mit einem sauberen Proxy stoßen Sie irgendwann an Ratenbegrenzungen, daher sollten Sie pro Sitzung oder pro Keyword rotieren. Ein detaillierteres Muster finden Sie in unserem Leitfaden zur Proxy-Rotation in Python. Wenn Ihnen die Verwaltung von Pools wie „Yak-Shaving“ vorkommt, kann ein verwaltetes Produkt für Residential-Proxys oder eine API auf Anforderungsebene wie die WebScrapingAPI Scraper API diese Arbeit übernehmen.

Checkliste für Stealth und Fingerabdruck-Hygiene

Pyppeteer wird ohne natives Stealth-Plugin ausgeliefert, daher müssen Sie den Browser selbst absichern. Die Checkliste für das Minimum an Sicherheitsmaßnahmen:

Legen Sie einen realistischen, aktuellen Desktop-User-Agent fest mit page.setUserAgent.
Passen Sie diesen mit einem plausiblen Viewport an page.setViewport (1366x768 oder 1440x900 sind sichere Standardeinstellungen).
Setze das navigator.webdriver Flag in einem evaluateOnNewDocument Hook, sodass er undefined statt true.
Achten Sie auf eine saubere Cookie-Verwaltung: Löschen Sie Cookies zwischen den Sitzungen oder wechseln Sie die Sitzungen, wenn Sie die IP-Adressen wechseln.
Wechseln Sie die IPs über private oder mobile Proxys für jedes Ziel mit strengen Bot-Abwehrmaßnahmen.
Drosseln Sie Anfragen und gestalten Sie das Timing menschlicher mit delay auf type und kleinen asyncio.sleep Lücken zwischen den Aktionen.

Bewährte Verfahren für den produktiven Einsatz im Jahr 2026

Wenn Sie einen Web-Scraper mit Pyppeteer wollen, der einen echten Zeitplan übersteht, halten Sie diese Regeln ein:

Führen Sie den Einstiegspunkt mit asyncio.run(main()). Vergessen Sie get_event_loop() und loop.run_until_complete(); die moderne Funktion ist übersichtlicher und weniger fehleranfällig.
Umschließe jeden Browser mit try/finally , damit der Chromium-Prozess auch dann beendet wird, wenn dein Code einen Fehler auslöst. Leckende Browser sind die Hauptursache für abgestürzte CI-Runner.
Verwenden Sie waitForSelector (explicit) gegenüber waitFor (vage). Verwende feste Wartezeiten nur für dokumentierte Anti-Bot-Verzögerungen.
Drosseln Sie höflich. Respektieren Sie robots.txtden Umfang auf öffentliche Daten und füge Jitter hinzu, damit nicht 100 Anfragen in 100 Millisekunden ankommen.
Fügen Sie strukturierte Protokollierung hinzu (eine JSON-Zeile pro Seite) und erfassen Sie die URL, den Status, die Antwortzeit und die Anzahl der Selektor-Treffer. Sie werden sich selbst dankbar sein, sobald eine Zielseite ihren HTML-Code ändert.

Wann Pyppeteer das falsche Werkzeug ist (und was man stattdessen verwenden sollte)

Pyppeteer eignet sich hervorragend für einmalige Skripte, interne Automatisierung und kleine Python-Codebasen, die bereits asyncio. Es stößt an seine Grenzen, sobald Sie browserübergreifende Abdeckung, neue CDP-Funktionen, offiziellen Stealth-Modus oder groß angelegte Parallelität benötigen. Orientieren Sie sich an dieser groben Entscheidungsregel:

Bleiben Sie bei Pyppeteer für Prototypen, Wochenend-Scraper und Skripte mit weniger als ein paar hundert Seiten pro Tag.
Wechseln Sie zu Playwright (Python), wenn Sie Firefox oder WebKit, robustes automatisches Warten oder erstklassiges Tracing benötigen.
Wechseln Sie zu Selenium, wenn Sie Safari unterstützen oder sich in ein bestehendes Test-Grid einbinden müssen.
Verwenden Sie eine gehostete Scraping-API, wenn Sie mehr Zeit mit Proxy-Rotation, CAPTCHAs und Headless-Infrastruktur verbringen als mit den eigentlichen Daten.

Wichtige Erkenntnisse

Pyppeteer ist die leicht gewartete Python-Portierung von Puppeteer; sie funktioniert auch 2026 noch für asyncio-basiertes Scraping, ist aber nicht die richtige Wahl für langlebige Produktionssysteme ohne Backup-Plan.
Verwenden Sie asyncio.run, try/finallyund waitForSelector anstelle der älteren Event-Loop- und waitFor Muster, die in veralteten Tutorials gezeigt werden.
Ein vollständiger Web-Scraper mit Pyppeteer deckt Wartezeiten, Formulareingaben, Screenshots, PDFs, unendliches Scrollen, die Wiederverwendung von Cookies und Proxys ab, nicht nur goto.
Es gibt kein natives Stealth-Plugin, daher liegen User-Agent, Viewport, navigator.webdriver, Cookie-Hygiene und wechselnde IPs liegen in Ihrer Verantwortung.
Entscheiden Sie sich für Playwright, Selenium oder eine verwaltete Scraping-API, sobald Ihr Scraper die Grenzen einer einzelnen Maschine, eines einzelnen Browsers oder eines einzelnen Proxys überschreitet.

FAQ

Wird Pyppeteer im Jahr 2026 noch gepflegt und ist die Nutzung sicher?

Nicht wirklich. Die Betreuer weisen im README des Projekts auf GitHub ausdrücklich darauf hin, dass Pyppeteer nur minimal gepflegt wird und neuere Puppeteer-Funktionen selten portiert werden. Es läuft zwar noch und scrapt weiterhin, aber für ein langlebiges Produktionssystem sollten Sie Playwright (Python) oder eine gehostete Scraping-API als aktiver entwickelte Alternative in Betracht ziehen, bevor Sie sich festlegen.

Was ist der Unterschied zwischen Pyppeteer und Puppeteer?

Puppeteer ist die offizielle Node.js-Bibliothek des Chrome-Teams zur Automatisierung von Chromium. Pyppeteer ist eine inoffizielle Python-Portierung, die den Großteil der Puppeteer-API widerspiegelt, jedoch asyncio anstelle von Promises. Pyppeteer hinkt bei neuen Funktionen in der Regel hinter Puppeteer her, und einige Puppeteer-APIs fehlen gänzlich, sodass die Ökosysteme zwar ähnlich aufgebaut sind, sich aber in ihrem Umfang unterscheiden.

Sollte ich für ein neues Python-Scraping-Projekt Pyppeteer, Playwright oder Selenium wählen?

Für ein neues Projekt im Jahr 2026 sollten Sie standardmäßig Playwright in Python wählen. Es wird aktiv weiterentwickelt, unterstützt Chromium, Firefox und WebKit und verfügt über eine automatische Wartefunktion, die viele Unregelmäßigkeiten beseitigt. Wählen Sie Selenium, wenn Sie Safari oder ein bestehendes Test-Grid benötigen. Wählen Sie Pyppeteer nur, wenn Sie ein älteres Skript erweitern, das es bereits verwendet.

Kann Pyppeteer Cloudflare, Bot-Erkennung oder CAPTCHAs selbstständig umgehen?

Nein. Pyppeteer wird ohne Stealth-Plugin ausgeliefert und verfügt über keinen integrierten CAPTCHA-Löser. Sie können Ihren Fingerabdruck manuell reduzieren, indem Sie einen realistischen User-Agent festlegen, navigator.webdriverund durch den Wechsel privater IP-Adressen, doch um moderne Cloudflare- oder hCaptcha-Hürden zuverlässig zu überwinden, ist in der Regel ein robustes Framework oder eine Scraping-API auf Anfrageebene erforderlich, die die Entsperrung für Sie übernimmt.

Warum stürzt mein Pyppeteer-Skript auf M1- oder M2-Macs ab?

Das mitgelieferte Chromium reagiert empfindlich auf Apple Silicon. Die gängigste Lösung besteht darin, Ihr Terminal unter Rosetta neu zu starten und pyppeteer-install, wodurch der x86_64-Chromium-Build sauber installiert und gestartet wird. Alternativ können Sie PYPPETEER_SKIP_CHROMIUM_DOWNLOAD=1 und verweisen Sie executablePath auf ein arm64bereits installierte native Version von Google Chrome.

Zusammenfassung

Die Erstellung eines Web-Scrapers mit Pyppeteer im Jahr 2026 ist immer noch eine vernünftige Wahl, wenn Sie ein kleines, asynchrones Python-Skript suchen, das ein echtes Chromium steuert. Sie verfügen über eine funktionierende Startervorlage, Muster für Wartezeiten, Formulare, Screenshots, unendliches Scrollen, Cookies und Proxys sowie eine Stealth-Checkliste und ein klares Gespür dafür, wann Sie zu Playwright, Selenium oder einer verwalteten Alternative wechseln sollten.

Das ehrliche Fazit: Da Pyppeteer nur noch in geringem Umfang gepflegt wird, sollten Sie es eher als taktisches Werkzeug denn als langfristige Plattform betrachten. Hüllen Sie Ihren Browser in try/finally, zieh waitForSelector feste Wartezeiten und planen Sie einen Migrationspfad ein für den Tag, an dem eine Zielseite ihre Bot-Abwehr schneller aktualisiert, als Pyppeteer die nächste CDP-Funktion portiert.

Wenn Proxy-Rotation, CAPTCHAs oder Chromium-Upgrades mehr Zeit in Anspruch nehmen als das Scraping selbst, übergib die Anforderungsschicht an die Scraper-API von WebScrapingAPI und konzentriere deinen Pyppeteer-Code darauf, die Daten zu parsen, die dir tatsächlich wichtig sind.