Selenium-Proxy in Python: Chrome, Edge, Login und SOCKS5

Ihr Selenium-Skript läuft, aber Sie brauchen die Seiten so, wie ein Besucher in Deutschland sie sieht, oder der Job muss von einem Server aus laufen, den die Website bereits drosselt. Sie tragen einen Proxy ein und bekommen eine leere Seite ohne Fehlermeldung. Meist liegt es am Passwort: Der WebDriver-Standard hat kein Feld für Proxy-Zugangsdaten, deshalb wird user:pass@host:port entweder abgelehnt oder stillschweigend ignoriert.

Diese Anleitung behandelt die Proxy-Einrichtung für Chrome, Edge und Firefox, die Anmeldewege, die heute funktionieren, SOCKS5, HTTPS, Rotation und die Fehlermeldungen. Jedes Python-Beispiel lief mit Selenium 4.49, Chrome 154, Edge 153 und Firefox 156 unter Windows 11 gegen einen lokalen Test-Proxy, der Benutzername und Passwort verlangt.

Was ist Selenium?#

Selenium steuert einen echten Webbrowser aus Code heraus. Verbreitet ist es vor allem im Test von Webanwendungen, es sammelt aber auch Daten von Seiten, die ihren Inhalt erst mit JavaScript aufbauen. Über seine Schnittstelle bedient ein Programm den Browser wie ein Mensch: Seiten laden, klicken, Text eingeben, Formulare abschicken und den Seiteninhalt auslesen. Ihr Code ruft die Selenium-Bibliothek auf, die Bibliothek spricht mit einem Treiber (ChromeDriver, msedgedriver oder geckodriver), und der Treiber steuert den Browser über das W3C-Protokoll WebDriver.

Selenium unterstützt Chrome, Edge, Firefox und Safari und bietet offizielle Anbindungen für Python, Java, C#, Ruby und JavaScript. Seit Version 4.6 bringt es Selenium Manager mit, der den installierten Browser findet und den passenden Treiber herunterlädt. Noch unentschieden, welches Werkzeug es sein soll? Lesen Sie Playwright oder Selenium: Welches Werkzeug passt?

Wie funktioniert ein Proxy in Selenium?#

In Selenium gehört der Proxy zur Browsersitzung, nicht zu einer einzelnen Anfrage:

1. Sie tragen den Proxy in die Browser-Optionen ein, als Chrome-Argument --proxy-server oder als Proxy-Objekt (die Capability proxy des WebDriver-Standards).
2. Der Treiber startet den Browser mit dieser Einstellung; sie gilt für jeden Tab bis driver.quit().
3. Für eine https://-Seite schickt der Browser CONNECT host:443 an den Proxy und öffnet einen verschlüsselten Tunnel. Für eine http://-Seite schickt er die vollständige URL an den Proxy.
4. Verlangt der Proxy eine Anmeldung, antwortet er mit 407 Proxy Authentication Required. Genau diesen Schritt deckt der WebDriver-Standard nicht ab.
5. Die Zielseite sieht die Ausgangs-IP des Proxys. Für einen anderen Proxy starten Sie einen neuen Browser.

Chrome schickt auch seinen eigenen Hintergrundverkehr (Updates, Kontodienste) über den Proxy; bei einem Tarif, der pro Gigabyte abrechnet, zählt das mit.

Wie nutzen Sie Selenium mit einem Proxy in Python?#

Schritt 1: Selenium installieren. Selenium 4.49 braucht Python 3.10 oder neuer:

pip install selenium

Schritt 2: Einen Proxy besorgen. Den passenden Dienst wählen Sie auf der Proxy-Seite. Der Endpoint-Generator im Proxynet-Panel liefert die Gateway-Adresse, den Port und einen Benutzernamen, der das gewählte Land, die Stadt und die Sitzung bereits enthält. HTTP und SOCKS5 laufen auf getrennten Ports desselben Gateways.

Schritt 3: Den Treiber bereitstellen. Ab Selenium 4.6 lädt Selenium Manager den passenden Treiber beim ersten Start selbst herunter. Ältere Anleitungen laden ChromeDriver von Hand herunter und übergeben den Pfad mit executable_path; diesen Parameter gibt es in aktuellen Versionen nicht mehr. Braucht der Rechner selbst einen Proxy, um ins Internet zu kommen, setzen Sie SE_PROXY für die Downloads von Selenium Manager.

Schritt 4: Den Browser mit dem Proxy starten. Für einen Proxy, der kein Passwort verlangt (IP-Whitelist, siehe unten):

from selenium import webdriver
from selenium.webdriver.common.by import By

PROXY = "http://pr.proxynet.io:8000"

options = webdriver.ChromeOptions()
options.add_argument(f"--proxy-server={PROXY}")
options.add_argument("--headless")  # entfernen, um den Browser zu sehen

driver = webdriver.Chrome(options=options)
try:
    driver.get("https://api.ipify.org/?format=json")
    print(driver.find_element(By.TAG_NAME, "body").text)  # {"ip": "<Ausgangs-IP>"}
finally:
    driver.quit()

Statt pr.proxynet.io:8000 setzen Sie Host und Port aus Ihrem Proxynet-Panel ein. Die ausgegebene IP sollte die Ausgangs-IP des Proxys sein. Das Proxy-Objekt von Selenium erledigt dieselbe Aufgabe (options.proxy = Proxy({"proxyType": ProxyType.MANUAL, "httpProxy": "host:port", "sslProxy": "host:port"})), und in unserem Test leiteten beide Formen den Verkehr gleich.

Wie nutzen Sie in Selenium einen Proxy mit Benutzername und Passwort?#

Die Proxy-Definition des W3C-WebDriver-Standards kennt Schlüssel für Proxy-Adressen, aber keinen für Benutzername oder Passwort, und laut der Proxy-Dokumentation von Chromium verwendet Chrome keine Zugangsdaten, die in den Proxy-Einstellungen stecken. Ein Argument --proxy-auth gibt es ebenfalls nicht, auch wenn manche älteren Anleitungen es verwenden. Unsere Tests gegen einen Proxy mit Anmeldung:

Die dritte Zeile ist die gefährliche: Das Skript scheint zu funktionieren, während der Verkehr am Proxy vorbeigeht. Anders als oft angenommen öffnet user:pass@ in --proxy-server auch kein Anmeldefenster; Chrome zeigt sofort die Fehlerseite.

Weg 1: IP-Whitelist#

Hinterlegen Sie im Proxynet-Panel die öffentliche IP des Rechners, auf dem das Skript läuft, in der IP-Whitelist; dann fragt der Proxy nicht mehr nach einem Passwort. Der Code aus Schritt 4 funktioniert unverändert, ebenso die Varianten für Edge und Firefox. Proxynet nimmt bis zu 10 IPs an. Das passt zu einem Server mit fester IP, nicht zu einem Laptop, dessen IP wechselt; siehe Proxy-Authentifizierung: User:Pass oder IP-Whitelist.

Weg 2: den 407 über das Chrome DevTools Protocol beantworten#

Chrome und Edge stellen die Fetch-Domain des DevTools Protocol bereit. Mit eingeschaltetem handleAuthRequests hält der Browser eine Anfrage, die Zugangsdaten braucht, an und löst Fetch.authRequired aus; dessen source ist Server oder Proxy. Der Helfer beantwortet nur Anfragen des Proxys; websocket-client wird mit Selenium mitinstalliert.

# proxy_auth.py
import json
import threading
import urllib.request

import websocket  # wird zusammen mit selenium installiert (websocket-client)


def attach_proxy_auth(driver, username, password):
    """Beantwortet die 407-Anfragen des Proxys für diesen Tab über das Chrome DevTools Protocol."""
    caps = driver.capabilities
    vendor = caps.get("goog:chromeOptions") or caps.get("ms:edgeOptions")  # Chrome oder Edge
    address = vendor["debuggerAddress"]
    with urllib.request.urlopen(f"http://{address}/json") as resp:
        targets = json.load(resp)
    page = next(t for t in targets if t["type"] == "page")
    ws = websocket.create_connection(page["webSocketDebuggerUrl"], suppress_origin=True)

    counter = {"id": 0}

    def send(method, params=None):
        counter["id"] += 1
        ws.send(json.dumps({"id": counter["id"], "method": method, "params": params or {}}))

    def listen():
        while True:
            try:
                msg = json.loads(ws.recv())
            except Exception:
                return  # der Browser wurde geschlossen
            method = msg.get("method")
            params = msg.get("params", {})
            if method == "Fetch.requestPaused":
                send("Fetch.continueRequest", {"requestId": params["requestId"]})
            elif method == "Fetch.authRequired":
                if params["authChallenge"]["source"] == "Proxy":
                    answer = {"response": "ProvideCredentials",
                              "username": username, "password": password}
                else:
                    answer = {"response": "Default"}  # die Anmeldung der Website selbst beantworten wir nicht
                send("Fetch.continueWithAuth", {"requestId": params["requestId"],
                                                "authChallengeResponse": answer})

    send("Fetch.enable", {"handleAuthRequests": True})
    while json.loads(ws.recv()).get("id") != counter["id"]:
        pass  # warten, bis das Abfangen aktiv ist, vor dem ersten driver.get()
    threading.Thread(target=listen, daemon=True).start()
    return ws

Für die Nutzung genügt eine Zeile, nachdem der Treiber gestartet ist:

from selenium import webdriver
from proxy_auth import attach_proxy_auth

options = webdriver.ChromeOptions()
options.add_argument("--proxy-server=http://pr.proxynet.io:8000")
driver = webdriver.Chrome(options=options)
attach_proxy_auth(driver, "user", "pass")
driver.get("https://api.ipify.org/?format=json")

Grenzen: Der Helfer gilt nur für den Tab, an den er sich angehängt hat; ein neues Fenster startet ohne ihn. Bei einem falschen Passwort zeigt Chrome ERR_TOO_MANY_RETRIES.

Und Selenium Wire oder Proxy-Erweiterungen?#

Das Repository von Selenium Wire wurde am 3. Januar 2024 archiviert, und in einer frischen Python-3.13-Umgebung scheiterte from seleniumwire import webdriver bei uns mit ModuleNotFoundError: No module named 'pkg_resources'. Erweiterungen für die Proxy-Anmeldung hingen am Schalter --load-extension, den offizielle Chrome-Builds ab Version 137 ignorieren; nur Chrome for Testing und Chromium akzeptieren ihn noch. SeleniumBase nimmt proxy="user:pass@host:port" an und erledigt die Anmeldung selbst; siehe Proxy mit SeleniumBase: Anmeldung und Rotation.

Welche Proxy-Methode sollten Sie in Selenium verwenden?#

Wie setzen Sie in Selenium einen Proxy für Microsoft Edge?#

Edge basiert auf Chromium, daher nimmt EdgeOptions dasselbe Argument an, und Selenium Manager lädt msedgedriver herunter:

from selenium import webdriver

options = webdriver.EdgeOptions()
options.add_argument("--proxy-server=http://pr.proxynet.io:8000")
driver = webdriver.Edge(options=options)

Der CDP-Helfer funktioniert auch mit Edge: Mit Edge 153 und dem passwortgeschützten Test-Proxy lud die Seite über den Proxy.

Wie setzen Sie in Selenium einen Proxy für Firefox?#

Firefox liest --proxy-server nicht. Setzen Sie stattdessen seine Netzwerk-Einstellungen (Preferences) oder übergeben Sie das Proxy-Objekt, das geckodriver in dieselben Einstellungen umsetzt. Auf unserem Testrechner war Firefox nicht installiert; Selenium Manager lud Firefox 156 beim ersten Start herunter.

from selenium import webdriver

options = webdriver.FirefoxOptions()
options.set_preference("network.proxy.type", 1)  # 1 = manuelle Konfiguration
options.set_preference("network.proxy.http", "pr.proxynet.io")
options.set_preference("network.proxy.http_port", 8000)
options.set_preference("network.proxy.ssl", "pr.proxynet.io")  # gilt für https://-Seiten
options.set_preference("network.proxy.ssl_port", 8000)
driver = webdriver.Firefox(options=options)

Für SOCKS5 setzen Sie network.proxy.socks und network.proxy.socks_port und stellen network.proxy.socks_version auf 5. Firefox schickt dann den Domainnamen an den Proxy, weil network.proxy.socks5_remote_dns standardmäßig eingeschaltet ist. Das ältere network.proxy.socks_remote_dns, das in vielen Anleitungen noch steht, änderte in Firefox 156 bei SOCKS5 nichts; setzten wir dagegen socks5_remote_dns auf False, löste Firefox die Namen lokal auf. Für Proxy-Zugangsdaten hat Firefox keine Einstellung, und der CDP-Helfer greift hier nicht. Selenium-BiDi add_auth_handler schickte unsere Zugangsdaten zwar, der Seitenaufruf scheiterte aber trotzdem mit UnexpectedAlertPresentException wegen des Anmeldefensters des Proxys. Nutzen Sie für Firefox daher eine IP-Whitelist.

Kann Selenium einen SOCKS5-Proxy nutzen?#

Ja, ohne Passwort: --proxy-server=socks5://host:port. In unserem Test schickte Chrome den Domainnamen an den Proxy, statt ihn lokal aufzulösen; die Chromium-Dokumentation bestätigt, dass bei SOCKS5 die Namensauflösung immer auf der Seite des Proxys stattfindet.

Mit Passwort nicht: Chromium unterstützt keine SOCKS5-Authentifizierung, und driver.get() löste net::ERR_SOCKS_CONNECTION_FAILED aus. Der CDP-Helfer hilft hier nicht, weil SOCKS keinen 407 kennt, den man beantworten könnte. Nutzen Sie den SOCKS5-Port mit Whitelist oder den HTTP-Port mit dem Helfer. Mehr dazu in Was ist ein SOCKS5-Proxy? und SOCKS und HTTP Proxy im Vergleich; der SOCKS5-Proxy von Proxynet läuft auf einem eigenen Port desselben Gateways.

Funktioniert Selenium über einen Proxy mit HTTPS-Seiten?#

Ja. Die Proxy-Adresse behält das Schema http://, auch wenn jede Seite https:// ist: Der Browser öffnet einen CONNECT-Tunnel, und TLS läuft durchgehend zwischen Browser und Website. Der Proxy sieht den Hostnamen, aber nicht den Inhalt. Deshalb braucht ein Proxy-Objekt neben httpProxy auch sslProxy; nur mit httpProxy gingen unsere https://-Seiten direkt hinaus, ohne Proxy.

Ein https://-Schema in --proxy-server verschlüsselt dagegen die Verbindung zum Proxy selbst; siehe HTTPS-Proxy.

Wie binden Sie Proxys in Selenium mit Java ein?#

Java nutzt dasselbe Proxy-Objekt. Verbreitete Beispiele schreiben user:pass@ in setHttpProxy; in unserem Test ging Chrome damit am Proxy vorbei. Die Version unten setzt deshalb auf eine IP-Whitelist. Sie verzichtet außerdem auf System.setProperty("webdriver.chrome.driver", …), weil Selenium Manager den Treiber findet. Selenium 4 braucht Java 11 oder neuer.

import org.openqa.selenium.Proxy;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class SeleniumProxyExample {
    public static void main(String[] args) {
        // Keine Zugangsdaten hier: Die IP des Rechners steht auf der Whitelist des Proxys
        String proxyAddress = "pr.proxynet.io:8000";

        Proxy proxy = new Proxy();
        proxy.setHttpProxy(proxyAddress);
        proxy.setSslProxy(proxyAddress);

        ChromeOptions options = new ChromeOptions();
        options.setProxy(proxy);

        // Selenium Manager findet oder lädt den passenden ChromeDriver
        WebDriver driver = new ChromeDriver(options);
        try {
            driver.get("https://api.ipify.org/?format=json");
            System.out.println(driver.getPageSource());
        } finally {
            driver.quit();
        }
    }
}

Auch hier gilt die Einschränkung von oben: Benutzername und Passwort gehören nicht in die Proxy-Adresse. options.addArguments("--proxy-server=http://pr.proxynet.io:8000") entspricht dem Argument aus dem Python-Beispiel. Dieses Beispiel haben wir nach der Selenium-Dokumentation geschrieben und nicht ausgeführt, weil auf dem Testrechner nur Java 8 installiert ist.

Wie rotieren Sie Residential-Proxys in Selenium?#

Der Proxy steht für die Lebensdauer eines Browsers fest, Rotation bedeutet also: einen neuen Browser starten.

• Rotierendes Gateway. Ist ein Rotierender Proxy im Einsatz, wechselt die Ausgangs-IP auf der Seite des Gateways, und Ihr Code behält eine einzige Adresse. Die Verbindungen eines Seitenaufrufs können dabei von verschiedenen IPs ausgehen: für Produktlisten kein Problem, für einen Login-Ablauf schon.
• Sticky-Sitzungen. Mit einem Sticky-Proxy bleibt die IP 1 bis 60 Minuten gleich. Geben Sie jedem Browser einen eigenen Sitzungs-Benutzernamen aus dem Endpoint-Generator: ein Browser, eine Sitzung, eine Ausgangs-IP.

Beides funktioniert mit einem Residential-Proxy, der sich für Ziele mit strenger Prüfung eignet. Für schnelle Abrufe auf unkritischen Seiten reicht ein Datacenter-Proxy; wer eine Sitzung über viele Schritte mit derselben festen Adresse halten muss, nimmt einen ISP-Proxy. Mehr dazu in Was ist IP-Rotation und wie funktioniert sie? und Proxys in Python rotieren.

Vollständiges Beispiel: parallele Browser mit Wiederholungen#

Das Skript liest sechs per JavaScript aufgebaute Seiten von quotes.toscrape.com, einer Übungsseite. Es lässt drei Chrome-Instanzen gleichzeitig laufen, startet bei jedem Versuch einen frischen Browser, blockiert Bilder, um Traffic zu sparen, und wiederholt vorübergehende Fehler mit wachsender Wartezeit. Fehler, die eine Wiederholung nicht behebt, beenden die Aufgabe sofort, auch solche, die nur auf der Fehlerseite von Chrome erscheinen.

import random
import re
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

from selenium import webdriver
from selenium.common.exceptions import TimeoutException, WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait

from proxy_auth import attach_proxy_auth

PROXY_SERVER = "http://pr.proxynet.io:8000"
PROXY_USER = "user"
PROXY_PASS = "pass"
URLS = [f"https://quotes.toscrape.com/js/page/{n}/" for n in range(1, 7)]
WORKERS = 3  # gleichzeitig geöffnete Browser
ATTEMPTS = 3
# Hier hilft keine Wiederholung: zuerst Adresse, Port und Zugangsdaten prüfen
FATAL = ("ERR_PROXY_CONNECTION_FAILED", "ERR_NO_SUPPORTED_PROXIES",
         "ERR_SOCKS_CONNECTION_FAILED", "ERR_TOO_MANY_RETRIES")


def new_driver():
    options = webdriver.ChromeOptions()
    options.add_argument(f"--proxy-server={PROXY_SERVER}")
    options.add_argument("--headless")
    # Bilder überspringen: weniger Traffic über den Proxy
    options.add_experimental_option("prefs", {"profile.managed_default_content_settings.images": 2})
    driver = webdriver.Chrome(options=options)
    driver.set_page_load_timeout(30)
    attach_proxy_auth(driver, PROXY_USER, PROXY_PASS)
    return driver


def scrape(url):
    for attempt in range(ATTEMPTS):
        driver = new_driver()  # bei jedem Versuch ein neuer Browser und eine neue Proxy-Verbindung
        try:
            driver.get(url)
            # Manche Proxy-Fehler öffnen die Fehlerseite von Chrome, ohne eine Exception auszulösen
            if driver.execute_script("return document.body.className") == "neterror":
                code = re.search(r"ERR_[A-Z_]+", driver.page_source)
                raise WebDriverException(code.group(0) if code else "Chrome error page")
            WebDriverWait(driver, 10).until(
                EC.presence_of_element_located((By.CSS_SELECTOR, "div.quote span.text"))
            )
            quotes = driver.find_elements(By.CSS_SELECTOR, "div.quote span.text")
            return url, [q.text for q in quotes]
        except (TimeoutException, WebDriverException) as exc:
            if any(code in str(exc) for code in FATAL) or attempt == ATTEMPTS - 1:
                raise
            time.sleep(2**attempt + random.random())  # exponentielles Backoff mit Jitter
        finally:
            driver.quit()


with ThreadPoolExecutor(max_workers=WORKERS) as pool:
    futures = [pool.submit(scrape, url) for url in URLS]
    for future in as_completed(futures):
        try:
            url, quotes = future.result()
            print(f"{url}: {len(quotes)} quotes")
        except Exception as exc:
            print("failed:", str(exc).splitlines()[0])

Alle sechs Seiten lieferten je 10 Zitate in rund 22 Sekunden. Ein geschlossener Port beendete jede Aufgabe mit net::ERR_PROXY_CONNECTION_FAILED, ein falsches Passwort mit ERR_TOO_MANY_RETRIES. Halten Sie die Zahl der Worker moderat: Jeder Worker ist ein vollständiger Chrome, und zu viele parallele Sitzungen führen zu 429 Too Many Requests.

Wie prüfen Sie, ob Selenium wirklich den Proxy nutzt?#

Öffnen Sie im Browser mit Proxy eine Seite, die Ihre IP zurückgibt, etwa api.ipify.org, und vergleichen Sie das Ergebnis mit Ihrer eigenen IP. Stimmen beide überein, geht der Verkehr am Proxy vorbei. Auch Ihr Panel sollte Traffic anzeigen. WebRTC kann trotzdem die lokale IP verraten; siehe WebRTC- und DNS-Lecks. Eine vollständige Prüfroutine steht in So testen Sie einen Proxy, eine Prüfung mit einer einzigen Zeile im Terminal in cURL mit Proxy verwenden.

Häufige Selenium-Proxy-Fehler und ihre Lösung#

Die Meldungen stammen aus unseren Tests. Chrome-Codes erscheinen in der Exception (unknown error: net::ERR_…) oder nur auf der Fehlerseite.

Verbindungsfehler einfacher Python-HTTP-Clients werden in Max Retries Exceeded With URL Zeile für Zeile erklärt.

Anwendungsfälle#

• Preisbeobachtung in Shops mit viel JavaScript, aus dem Markt, in dem Sie verkaufen: Wettbewerberpreise überwachen und Preisüberwachung.
• Lokalisierung und QA: die eigene Website vor einem Release aus mehreren Ländern laden, siehe App-Tests.
• Anzeigenprüfung: Ihre Anzeigen in den Regionen kontrollieren, für die Sie bezahlen, siehe Anzeigenverifizierung.
• Datenerfassung von Seiten, die JavaScript brauchen: Data Scraping.

Ein Proxy ändert, woher die Anfrage kommt, nicht, was die Website erlaubt: Lesen Sie ihre robots.txt und Nutzungsbedingungen, halten Sie die Anfragerate niedrig und greifen Sie bevorzugt auf eine offizielle API zurück. Automatisierung verbirgt ein Proxy ebenfalls nicht; ein Browser unter WebDriver-Steuerung meldet navigator.webdriver als true, so wie es der Standard verlangt.

Entscheidungshilfe#

Häufige Fragen#

Kann Selenium einen Proxy mit Benutzername und Passwort nutzen?#

Nicht über die Standardoptionen, denn sie haben keine Felder für Zugangsdaten. In Chrome und Edge beantwortet der DevTools-Helfer aus diesem Beitrag den 407 des Proxys; in jedem Browser macht eine IP-Whitelist das Passwort überflüssig.

Funktioniert Selenium Wire 2026 noch?#

Das Projekt wurde am 3. Januar 2024 archiviert, und in einer frischen Python-3.13-Umgebung ließ es sich bei uns nicht importieren, weil es auf pkg_resources angewiesen ist, das aktuelle setuptools-Versionen nicht mehr mitliefern. Nutzen Sie den Helfer oder eine Whitelist.

Wie wechsle ich den Proxy, ohne den Browser neu zu starten?#

Der Proxy steht beim Start der Sitzung fest: Rufen Sie driver.quit() auf und starten Sie einen neuen Treiber. Für eine neue IP pro Seite in einem einzigen Browser nutzen Sie ein rotierendes Gateway oder Playwright, das einen Proxy pro Kontext annimmt.

Funktioniert ein Proxy im Headless-Modus?#

Ja. --proxy-server und der CDP-Helfer verhalten sich mit und ohne --headless gleich; alle Beispiele in diesem Beitrag liefen headless.

Kann ich in Selenium einen SOCKS5-Proxy mit Authentifizierung nutzen?#

Nicht in Chrome oder Edge, denn beide unterstützen keine SOCKS5-Authentifizierung; auch Firefox 156 bot unserem Proxy nur die Methode ohne Passwort an. Nutzen Sie SOCKS5 mit Whitelist oder den HTTP-Port mit Passwort.

Warum zeigt die Website noch meine echte IP?#

Meist wurde der Proxy gar nicht angewendet: Zugangsdaten im Proxy-Objekt lassen Chrome direkt verbinden, und ein Proxy-Objekt ohne sslProxy schickt https://-Seiten ohne Proxy hinaus. Stimmt die IP, wirkt der Standort aber falsch, prüfen Sie auf WebRTC-Lecks.

Fazit#

Selenium setzt den Proxy einmal pro Browsersitzung: --proxy-server für Chrome und Edge, Einstellungen oder das Proxy-Objekt für Firefox. Für die Anmeldung nutzen Sie eine IP-Whitelist oder, in Chrome und Edge, den DevTools-Helfer, der den 407 beantwortet; Selenium Wire und Erweiterungen über die Kommandozeile sind Sackgassen. SOCKS5 funktioniert nur ohne Passwort, und Rotation heißt: ein Browser pro IP oder Sitzung. Ist die Einrichtung fertig, wählen Sie einen Tarif auf der Proxynet-Proxy-Seite und übernehmen die Gateway-Daten aus dem Endpoint-Generator.