Selenium Wire Proxy einrichten: Vollständiger Python-Leitfaden

Ein Selenium Wire Proxy ist der schnellste Weg, authentifizierte Browserautomatisierung in Python auszuführen, denn Selenium Wire akzeptiert eine login:password-Proxy-URL direkt in einer Option, statt den Erweiterungs-Workaround zu erzwingen, den reines Selenium benötigt. Außerdem stellt es jeden HTTP-Request und jede Response bereit, die der Browser ausführt, weshalb Scraping- und QA-Teams darauf setzen.

Dieser Leitfaden führt Sie umfassend durch die Einrichtung. Er behandelt die sichere Installation und Versionsfixierung der Bibliothek, die Einbindung eines authentifizierten Proxy, die Prüfung der Exit-IP, das Untersuchen und Abwarten von Requests, das Bearbeiten von Headern, die Rotation von IPs, den Headless-Betrieb, die Speicheroptimierung, den sachgerechten Umgang mit dem HTTPS-Zertifikat, die Kombination mit undetected-chromedriver sowie den Einsatzbereich moderner Alternativen.

DataImpulse ist ein ethischer Proxy-Anbieter mit mehr als 90 Millionen privaten, mobilen und Datacenter-IP-Adressen in 195 Ländern. Das Pay-as-you-go-Modell beginnt bei 1 Dollar pro GB und umfasst nicht verfallenden Traffic. Es wird für Web Scraping, Anzeigenverifizierung, Preisüberwachung, Marktforschung und die Verwaltung mehrerer Accounts genutzt.

Was ist Selenium Wire und wird es noch gepflegt?

Selenium Wire ist eine Python-Bibliothek, die Selenium erweitert, sodass Ihr Skript die HTTP-Requests und Responses des Browsers untersuchen, darauf warten und sie verändern kann. Zudem bietet sie erstklassige Unterstützung für authentifizierte Proxies. Dazu wird ein lokaler Man-in-the-Middle-Proxy ausgeführt, auf den der Browser zeigt und der den Traffic an Ihren tatsächlichen Upstream-Proxy weiterleitet.

Der ehrliche Vorbehalt: Das Originalprojekt ist archiviert und wird nicht mehr aktiv gepflegt. Im Produktivbetrieb funktioniert es weiterhin gut, doch Sie sollten Ihre Versionen fixieren und jedes Upgrade von Selenium, Chrome oder Abhängigkeiten isoliert testen, bevor Sie es ausliefern. Es gibt Community-Forks mit Kompatibilitätskorrekturen; die Vergleichstabelle weiter unten zeigt, wann ein gepflegtes Tool wie Playwright langfristig die bessere Wahl ist.

Teams wählen es weiterhin vor allem aus Bequemlichkeit. Wenn Sie bereits eine Selenium-Testsuite oder einen Scraper haben, genügt für Selenium Wire eine einzeilige Änderung beim Import plus eine Proxy-Option. Sie erhalten sofort sowohl Unterstützung für authentifizierte Proxies als auch die Möglichkeit, jeden Request der Seite zu lesen. Diese Sichtbarkeit auf Request-Ebene in reinem Selenium nachzubauen, ist echte Arbeit. Für bestehende Codebasen lohnt sich der Kompromiss daher trotz des archivierten Status oft. Wenn Sie neu in der Steuerung echter Browser zur Datenerhebung sind, erläutert unser Leitfaden zum Scraping dynamischer Webseiten den umfassenderen Kontext des Renderings und wann ein Browser überhaupt notwendig ist.

Wie installieren Sie Selenium Wire und fixieren Versionen, um Fehler zu vermeiden?

Installieren Sie selenium-wire zusammen mit selenium und fixieren Sie blinker auf eine Version unter 1.8, weil dieses Release einen internen Namen entfernt hat, den Selenium Wire beim Start importiert. Da das Projekt archiviert ist, sind nicht fixierte Abhängigkeiten der häufigste Grund dafür, dass eine funktionierende Einrichtung plötzlich scheitert.

Der klassische Fehler ist ein ImportError bei WeakNamespace nach einem automatischen blinker-Upgrade. Eine Versionsfixierung verhindert ihn:

# Selenium Wire is archived. Pin known-good versions so an upstream release
# does not break your build overnight.
#
# blinker >= 1.8 removed blinker._saferef / WeakNamespace, which Selenium Wire
# imports at startup. On blinker 1.8+ you get:
#   ImportError: cannot import name 'WeakNamespace' from 'blinker'
# The fix is to hold blinker below 1.8.
pip install "selenium-wire==5.1.0" "selenium==4.9.1" "blinker==1.7.0"

# Selenium Wire also depends on brotli and can trip on very new Selenium.
# If you must run current Selenium, test in a throwaway virtualenv first, or
# move to a maintained fork such as selenium-wire-2 that tracks these fixes.

Halten Sie diese Fixierungen in einer Requirements-Datei fest, damit Continuous Integration und Teammitglieder dieselbe bewährte Kombination erhalten. Wenn Sie auf die aktuelle Selenium-Version wechseln möchten, behandeln Sie dies als gezieltes Upgrade mit einem eigenen Testlauf, statt pip einfach die neuesten Versionen von allem auflösen zu lassen.

Wie richten Sie einen authentifizierten Proxy in Selenium Wire ein?

Übergeben Sie beim Erstellen des Driver ein Proxy-Dictionary in seleniumwire_options, mit Benutzername und Passwort in der URL sowie über no_proxy ausgeschlossenem localhost. Genau diese Funktion macht Selenium Wire für Proxy-Arbeit gegenüber reinem Selenium besonders wertvoll.

Importieren Sie webdriver aus seleniumwire, nicht aus selenium, und übergeben Sie ihm anschließend die Optionen. Zugangsdaten, Host und Port finden Sie im Dashboard Ihres Anbieters. Bei DataImpulse lautet der Host gw.dataimpulse.com und der Port 823:

from seleniumwire import webdriver  # import from seleniumwire, not selenium

proxy_url = "http://login:[email protected]:823"

seleniumwire_options = {
    "proxy": {
        "http": proxy_url,
        "https": proxy_url,
        "no_proxy": "localhost,127.0.0.1",
    }
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://example.com")
print(driver.title)
driver.quit()

Der Eintrag no_proxy hält lokale Adressen vom Proxy fern, damit der Driver direkt mit ChromeDriver kommunizieren kann. Bei falscher Authentifizierung sehen Sie typischerweise eine 407-Response. Unser Hinweis zum Fehler 407 Proxy Authentication Required erklärt die Diagnose. Hintergrundwissen zur Funktionsweise von Proxies mit Zugangsdaten finden Sie unter Residential Proxies.

Wie prüfen Sie, ob die Proxy-Exit-IP funktioniert?

Rufen Sie mit dem Driver einen IP-Echo-Endpunkt wie api.ipify.org auf und prüfen Sie, ob die zurückgegebene Adresse zum Proxy gehört und nicht zu Ihrem eigenen Rechner. Gehen Sie niemals allein wegen einer geladenen Seite davon aus, dass der Proxy aktiv ist.

import json
from seleniumwire import webdriver

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"}
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://api.ipify.org/?format=json")

body = driver.find_element("tag name", "body").text
exit_ip = json.loads(body)["ip"]
print("Exit IP:", exit_ip)  # should be the proxy, not your own address

driver.quit()

Wenn die Response Ihre echte IP zeigt, sollten Sie drei Dinge prüfen: ob no_proxy nicht versehentlich auf Ihr Ziel zutrifft, ob die Zugangsdaten korrekt sind und ob Sie webdriver aus seleniumwire importiert haben. Führen Sie diese Prüfung als ersten Schritt jedes neuen Jobs durch und wiederholen Sie sie nach Änderungen an den Proxy-Einstellungen.

Wie untersuchen Sie bestimmte Requests und warten darauf?

Lesen Sie driver.requests, um jeden Request und jede Response des Browsers zu durchlaufen, und verwenden Sie driver.wait_for_request, um bis zum Erscheinen eines passenden Aufrufs zu warten. Diese Fähigkeit unterscheidet Selenium Wire von einem normalen WebDriver und ist unverzichtbar, um die JSON API hinter einer Seite zu finden.

from seleniumwire import webdriver

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://example.com/products")

# Block until a request whose URL matches the regex is captured.
request = driver.wait_for_request(r"/api/v2/products", timeout=15)
print(request.method, request.url)
print("Status:", request.response.status_code)
print("Type:", request.response.headers["Content-Type"])

# Walk every captured request/response pair the browser made.
for r in driver.requests:
    if r.response:
        print(r.response.status_code, r.url)

driver.quit()

Der Aufruf wait_for_request akzeptiert einen regulären Ausdruck, der mit der URL abgeglichen wird, und gibt zurück, sobald der Request erfasst wurde. So vermeiden Sie anfällige feste Wartezeiten. Sobald Sie wissen, welcher Hintergrundaufruf die Daten enthält, können Sie das Rendering oft vollständig überspringen und diesen Endpunkt direkt aufrufen, was deutlich günstiger ist. Diese Technik ist zentral für Best Practices für Web Scraping.

Wie ändern Sie Request-Header mit einem Interceptor?

Weisen Sie driver.request_interceptor eine Funktion zu. Sie wird ausgeführt, bevor jeder Request den Browser verlässt, und ermöglicht es Ihnen, Header zu überschreiben, Token einzufügen oder Parameter zu entfernen. Ein realistischer User-Agent und eine passende Sprache sind ein häufiger Grund dafür.

from seleniumwire import webdriver

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)

def interceptor(request):
    # Delete first, then set, so you replace the header instead of duplicating it.
    del request.headers["User-Agent"]
    request.headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
    request.headers["Accept-Language"] = "en-US,en;q=0.9"

driver.request_interceptor = interceptor
driver.get("https://httpbin.org/headers")
print(driver.find_element("tag name", "body").text)
driver.quit()

Löschen Sie den vorhandenen Header, bevor Sie einen neuen Wert setzen, da Selenium Wire sonst sowohl das Original als auch Ihren Ersatz senden kann. Mit einem entsprechenden response_interceptor können Sie Responses lesen oder umschreiben. Halten Sie Interceptors schlank, da sie bei jedem Request ausgeführt werden, auch für Bilder und Skripte. Einheitliche, menschlich wirkende Header sind eines der subtileren Signale in Best Practices für Web Scraping.

Wie rotieren Sie Proxies pro Request in Selenium Wire?

Es gibt zwei Muster: Weisen Sie driver.proxy zur Laufzeit neu zu, um die Konfiguration im selben Browser zu wechseln, oder erstellen Sie den Driver neu, wenn Sie zusätzlich ein sauberes Profil und einen leeren Cookie-Speicher wünschen. Ein rotierendes Gateway wie DataImpulse vergibt bei neuen Verbindungen bereits einen neuen Residential Exit, daher müssen die meisten Jobs nur für ein anderes Land die Konfiguration wechseln.

from seleniumwire import webdriver

base = "http://login:[email protected]:823"
opts = {"proxy": {"http": base, "https": base,
                  "no_proxy": "localhost,127.0.0.1"}}
driver = webdriver.Chrome(seleniumwire_options=opts)

# Option A: reassign driver.proxy at runtime to switch config (for example a
# different country gateway) without rebuilding the browser. Cheap and fast.
uk = "http://login:[email protected]:823"
driver.proxy = {"http": uk, "https": uk, "no_proxy": "localhost,127.0.0.1"}
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

# Option B: recreate the driver per job when you need a guaranteed clean
# browser profile and cookie jar as well as a fresh exit IP.
def fresh_driver():
    return webdriver.Chrome(seleniumwire_options=opts)

for _ in range(3):
    d = fresh_driver()
    d.get("https://api.ipify.org")
    print(d.find_element("tag name", "body").text)
    d.quit()

Das Neuzuweisen von driver.proxy ist günstig und hält den Browser warm, was zu Schleifen mit hohem Volumen passt, bei denen die Startkosten dominieren. Den Driver neu zu erstellen ist aufwendiger, garantiert aber die Isolierung zwischen Jobs. Das ist wichtig, wenn ein Ziel Sessions an Cookies und lokalen Speicher ebenso wie an die IP bindet. Wählen Sie danach, ob Sie eine saubere Identität oder nur eine neue Adresse benötigen. Eine praktische Regel lautet: Weisen Sie den Proxy beim Sammeln anonymer öffentlicher Seiten neu zu und erstellen Sie den Driver neu, sobald Sie eine Account- oder Login-Grenze überschreiten, damit ein durchsickerndes Cookie aus einem Durchlauf nicht in den nächsten gelangt. Bei mobilen Zielen mit aggressivem Fingerprinting lohnen sich oft Mobile Proxies für die schwierigsten Fälle, während weniger anspruchsvolle Seiten günstigere Exits nutzen können.

Wie führen Sie Selenium Wire headless aus und halten den Speicherverbrauch niedrig?

Fügen Sie Chrome-Optionen für Headless-Modus und Stabilität hinzu und begrenzen Sie anschließend, was Selenium Wire erfasst, damit der Request-Puffer nicht unbegrenzt wächst. Auf Servern entscheidet Headless-Betrieb mit begrenzter Erfassung darüber, ob ein Job stundenlang läuft oder den RAM erschöpft.

Beginnen Sie mit einer soliden Auswahl an Chrome-Flags für einen Headless-Container oder eine CI-Umgebung:

from seleniumwire import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument("--headless=new")     # modern headless mode
chrome_options.add_argument("--no-sandbox")
chrome_options.add_argument("--disable-dev-shm-usage")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--window-size=1920,1080")

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"}
}

driver = webdriver.Chrome(options=chrome_options,
                          seleniumwire_options=seleniumwire_options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

Standardmäßig erfasst und puffert Selenium Wire jeden Request und jede Response, was bei langen Läufen Speicher verbraucht. Begrenzen Sie die Erfassung mit driver.scopes, behalten Sie den Speicher im Arbeitsspeicher und leeren Sie den Puffer zwischen den Seiten:

from seleniumwire import webdriver

seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"},
    "request_storage": "memory",   # keep the buffer in RAM, not on disk
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)

# Only capture the API traffic you care about. Images, fonts, analytics, and
# tracking pixels are ignored, which keeps the capture buffer small.
driver.scopes = [r".*/api/.*"]

driver.get("https://example.com/products")
for request in driver.requests:
    print(request.url)

del driver.requests   # clear the buffer between pages on long-running jobs
driver.quit()

Die Liste scopes ist eine Menge von URL-RegEx; alles außerhalb wird durchgeleitet, aber nicht gespeichert. Bei einem Scraper, der nur die API-Responses benötigt, kann dies den belegten Puffer drastisch reduzieren. Weniger herunterzuladen senkt auch die Proxy-Kosten, da DataImpulse-Traffic pro Gigabyte abgerechnet wird.

Wie verarbeitet Selenium Wire HTTPS und sein Zertifikat?

Um verschlüsselte Request- und Response-Bodys lesen zu können, entschlüsselt Selenium Wire HTTPS als Man-in-the-Middle mit einem eigenen Root-Zertifikat, das automatisch in das Browserprofil für Chrome und Firefox eingefügt wird. Das ist leistungsstark, hat aber klare Grenzen, die Sie kennen sollten, bevor Sie sich darauf verlassen.

from seleniumwire import webdriver

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"},
    # Selenium Wire is a man-in-the-middle proxy: to read HTTPS bodies it
    # decrypts traffic using its own root certificate, which it injects into
    # the browser profile automatically. These two options relax verification
    # on the upstream leg so a mismatched or self-signed cert does not abort.
    "verify_ssl": False,
    "suppress_connection_errors": True,
}

driver = webdriver.Chrome(seleniumwire_options=seleniumwire_options)
driver.get("https://example.com")
driver.quit()

Aus dem Man-in-the-Middle-Design folgen zwei Dinge. Erstens wird eine Seite mit Certificate Pinning das eingefügte Zertifikat ablehnen, sodass das Abfangen dieses Traffic fehlschlägt. Deaktivieren Sie in diesem Fall die Erfassung für den betroffenen Host oder verzichten Sie darauf, seine Bodys zu untersuchen. Zweitens müssen Sie bei einem benutzerdefinierten oder nicht standardmäßigen Chrome-Profil gegebenenfalls sicherstellen, dass die Selenium Wire CA dort vertraut wird. Die Optionen verify_ssl und suppress_connection_errors lockern die Upstream-Prüfung, damit ein ungewöhnliches Zertifikat den Lauf nicht abbricht, umgehen Pinning aber nicht.

Können Sie undetected-chromedriver kombinieren, und welche Alternativen gibt es?

Ja. Selenium Wire enthält eine undetected-chromedriver-Integration, die Sie als seleniumwire.undetected_chromedriver importieren. Sie erhalten damit Request-Inspektion und authentifizierte Proxies, während undetected-chromedriver Automatisierungs-Fingerprints reduziert. Für geschützte Ziele ist dies die bevorzugte Kombination.

# Selenium Wire ships its own undetected-chromedriver integration.
import seleniumwire.undetected_chromedriver as uc

proxy_url = "http://login:[email protected]:823"
seleniumwire_options = {
    "proxy": {"http": proxy_url, "https": proxy_url,
              "no_proxy": "localhost,127.0.0.1"}
}

options = uc.ChromeOptions()
options.add_argument("--headless=new")

driver = uc.Chrome(seleniumwire_options=seleniumwire_options, options=options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

Wenn Selenium Wire selbst nicht passt, decken zwei Alternativen die meisten Anforderungen ab. Reines Selenium 4 kann über eine kleine generierte Erweiterung einen authentifizierten Proxy nutzen, was eine Hilfsbibliothek automatisiert:

from selenium import webdriver
# Plain Selenium cannot send proxy credentials on its own. A small helper builds
# a throwaway Chrome extension that answers the proxy auth challenge for you.
from selenium_authenticated_proxy import SeleniumAuthenticatedProxy

proxy = SeleniumAuthenticatedProxy(
    proxy_url="http://login:[email protected]:823"
)
options = webdriver.ChromeOptions()
proxy.enrich_options(options)

driver = webdriver.Chrome(options=options)
driver.get("https://api.ipify.org")
print(driver.find_element("tag name", "body").text)
driver.quit()

Playwright verarbeitet authentifizierte Proxies nativ und wird aktiv gepflegt, weshalb es die bessere Grundlage für neue Projekte ist:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=True,
        proxy={
            "server": "http://gw.dataimpulse.com:823",
            "username": "login",
            "password": "password",
        },
    )
    page = browser.new_page()
    page.goto("https://api.ipify.org")
    print(page.inner_text("body"))
    browser.close()

So vergleichen sich die drei speziell bei der Arbeit mit authentifizierten Proxies:

Migrationsrat: Wenn Sie nur Proxies mit Zugangsdaten und keine Request-Erfassung benötigen, ist reines Selenium mit einer Auth-Erweiterung die schlankste Lösung und bleibt auf gepflegtem Code. Wenn Sie Traffic untersuchen oder umschreiben müssen und neu beginnen, bietet Playwright dies nativ ohne den Aufwand der Versionsfixierung. Behalten Sie Selenium Wire, wenn Sie eine bestehende Selenium-Codebasis haben, deren Kontrolle auf Request-Ebene teuer nachzubauen wäre. Für die Wahl der IPs in jedem dieser Tools vergleichen Sie Residential Proxies, Datacenter Proxies, and Mobile Proxies mit den Schutzmaßnahmen Ihres Ziels.

Häufig gestellte Fragen

Verwandte Leitfäden

• Dynamische Webseiten scrapen
• Was ist Proxy-Authentifizierung?
• Best Practices für Web Scraping

Selenium Wire über zuverlässige Proxies ausführen

Ein Selenium Wire Proxy ist nur so gut wie die IPs dahinter. Sie können Ihre Browserautomatisierung über ethisch beschaffte Residential-, Mobile- oder Datacenter-IPs mit Pay-as-you-go-Traffic ab 1 Dollar pro GB leiten. Ein DataImpulse-Konto erstellen und mit rotierenden oder Sticky Sessions beginnen.