Proxy-Einstellungen in Selenium: Ein Leitfaden mit Codebeispielen

```html

Selenium WebDriver ist eines der beliebtesten Tools zur Automatisierung von Browsern und zum Scraping von Daten. Bei der Arbeit mit großen Mengen an Anfragen oder beim Umgehen geografischer Einschränkungen ist es entscheidend, Proxys richtig einzurichten. In diesem Leitfaden werden wir alle Möglichkeiten zur Integration von Proxys in Selenium für verschiedene Browser und Programmiersprachen untersuchen und typische Probleme lösen, mit denen Entwickler konfrontiert sind.

Warum Proxys in Selenium benötigt werden

Bei der Automatisierung von Web-Scraping oder Tests mit Selenium treten mehrere Aufgaben auf, die ohne Proxys nicht gelöst werden können:

Umgehung von Rate Limiting — viele Websites beschränken die Anzahl der Anfragen von einer IP-Adresse. Ohne Proxys wird Ihr Skript schnell nach 50-100 Anfragen blockiert.
Geografische Einschränkungen — wenn Sie Inhalte scrapen müssen, die nur aus einem bestimmten Land verfügbar sind, löst ein Proxy mit der benötigten Geolokalisierung dieses Problem.
Lastverteilung — bei massenhaften Daten-Scraping ermöglicht die Rotation von IP-Adressen über Proxys die Verteilung der Anfragen und vermeidet die Erkennung von Bots.
Testen der Lokalisierung — um zu überprüfen, wie eine Website für Benutzer aus verschiedenen Ländern angezeigt wird, sind Proxys aus den entsprechenden Regionen erforderlich.
Umgehung von Anti-Bot-Systemen — moderne Schutzmaßnahmen (Cloudflare, DataDome) analysieren die IP-Reputation. Hochwertige Proxys helfen, wie ein normaler Benutzer auszusehen.

Ohne die richtige Proxy-Einrichtung wird Ihr Selenium-Skript instabil arbeiten: es wird Captchas erhalten, temporäre Sperren oder vollständige Zugriffsblockierungen. Dies ist besonders kritisch beim Scraping von E-Commerce-Plattformen, sozialen Netzwerken oder Websites mit aggressiven Bot-Schutzmaßnahmen.

Welche Proxy-Typen verwendet werden sollten

Die Wahl des Proxy-Typs hängt von der Aufgabe ab. Für die Selenium-Automatisierung werden drei Haupttypen von Proxys verwendet, jeder mit seinen eigenen Vorteilen:

Proxy-Typ	Geschwindigkeit	Anonymität	Beste Szenarien
Rechenzentrums-Proxys	Sehr hoch (100+ Mbit/s)	Mittel	Scraping öffentlicher Daten, Leistungstests, Massenprüfungen
Residential Proxys	Mittel (10-50 Mbit/s)	Sehr hoch	Umgehung von Anti-Bot-Systemen, Scraping von sozialen Netzwerken, E-Commerce, Websites mit strengen Schutzmaßnahmen
Mobile Proxys	Mittel (5-30 Mbit/s)	Maximal	Arbeiten mit mobilen Versionen von Websites, soziale Netzwerke, Anwendungen mit Überprüfung mobiler IPs

Empfehlungen zur Auswahl:

Für das Scraping von Nachrichten-Websites, offenen APIs, einfachen Katalogen — Rechenzentrums-Proxys sind geeignet. Sie sind günstiger und schneller.
Für die Arbeit mit Amazon, eBay, Google, sozialen Netzwerken — nur Residential Proxys. Diese Plattformen blockieren aktiv IPs von Rechenzentren.
Für die Emulation mobiler Benutzer oder die Arbeit mit Instagram, TikTok — mobile Proxys sind unverzichtbar.
Für das Testen der Geolokalisierung — wählen Sie Proxys mit der Möglichkeit, ein bestimmtes Land und eine Stadt auszuwählen.

Proxy-Einrichtung für Chrome in Selenium

Chrome WebDriver ist die beliebteste Wahl für die Selenium-Automatisierung. Die Proxy-Einrichtung erfolgt über das Objekt ChromeOptions. Lassen Sie uns einige Methoden betrachten.

Methode 1: HTTP/HTTPS-Proxys ohne Authentifizierung (Python)

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

# Proxy-Einrichtung
PROXY = "123.45.67.89:8080"  # Ersetzen Sie durch Ihren Proxy-Server

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{PROXY}')

# Zusätzliche Optionen für Stabilität
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')

# Starten des Drivers
driver = webdriver.Chrome(options=chrome_options)

# IP-Überprüfung
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()

Methode 2: SOCKS5-Proxys (Python)

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

PROXY = "123.45.67.89:1080"

chrome_options = Options()
# Für SOCKS5 geben wir das Protokoll explizit an
chrome_options.add_argument(f'--proxy-server=socks5://{PROXY}')

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Wichtig: Chrome unterstützt HTTP, HTTPS und SOCKS5-Proxys. Für SOCKS4 sind zusätzliche Einstellungen oder die Verwendung von Erweiterungen erforderlich.

Proxy-Einrichtung für Chrome in Java

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

public class ChromeProxyExample {
    public static void main(String[] args) {
        // Proxy-Einrichtung
        Proxy proxy = new Proxy();
        proxy.setHttpProxy("123.45.67.89:8080");
        proxy.setSslProxy("123.45.67.89:8080");
        
        ChromeOptions options = new ChromeOptions();
        options.setProxy(proxy);
        options.addArguments("--no-sandbox");
        
        WebDriver driver = new ChromeDriver(options);
        driver.get("https://httpbin.org/ip");
        
        System.out.println(driver.getPageSource());
        driver.quit();
    }
}

Proxy-Einrichtung für Firefox in Selenium

Firefox WebDriver verwendet einen anderen Ansatz zur Proxy-Einrichtung über das Browser-Profil. Dies bietet mehr Flexibilität, erfordert jedoch ein Verständnis der Konfigurationsparameter.

HTTP/HTTPS-Proxys für Firefox (Python)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080

firefox_options = Options()

# Proxy-Einrichtung über Preferences
firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# Deaktivierung des Proxys für lokale Adressen
firefox_options.set_preference("network.proxy.no_proxies_on", "localhost,127.0.0.1")

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

SOCKS5-Proxys für Firefox (Python)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 1080

firefox_options = Options()

firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.socks", PROXY_HOST)
firefox_options.set_preference("network.proxy.socks_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.socks_version", 5)

# Für SOCKS5 mit DNS über Proxy
firefox_options.set_preference("network.proxy.socks_remote_dns", True)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Vorteil von Firefox: Der Parameter network.proxy.socks_remote_dns ermöglicht es, DNS-Anfragen über den Proxy auszuführen, was die Anonymität erhöht und hilft, DNS-Sperren zu umgehen.

Arbeiten mit Proxys, die Authentifizierung erfordern

Die meisten hochwertigen Proxy-Dienste verwenden eine Authentifizierung mit Benutzername und Passwort. Selenium unterstützt die direkte Übertragung von Anmeldeinformationen in die Proxy-URL für Chrome nicht, daher sind Umgehungslösungen erforderlich.

Methode 1: Chrome-Erweiterung zur Authentifizierung (empfohlen)

Erstellen Sie eine temporäre Chrome-Erweiterung, die automatisch Benutzername und Passwort bei der Verbindung mit dem Proxy einfügt:

import os
import zipfile
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080
PROXY_USER = "username"
PROXY_PASS = "password"

# Erstellung des Manifestes der Erweiterung
manifest_json = """
{
    "version": "1.0.0",
    "manifest_version": 2,
    "name": "Chrome Proxy",
    "permissions": [
        "proxy",
        "tabs",
        "unlimitedStorage",
        "storage",
        "webRequest",
        "webRequestBlocking"
    ],
    "background": {
        "scripts": ["background.js"]
    }
}
"""

# Skript zur Authentifizierung
background_js = """
var config = {
    mode: "fixed_servers",
    rules: {
        singleProxy: {
            scheme: "http",
            host: "%s",
            port: parseInt(%s)
        },
        bypassList: ["localhost"]
    }
};

chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

function callbackFn(details) {
    return {
        authCredentials: {
            username: "%s",
            password: "%s"
        }
    };
}

chrome.webRequest.onAuthRequired.addListener(
    callbackFn,
    {urls: [""]},
    ['blocking']
);
""" % (PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS)

# Erstellung der Erweiterung
plugin_path = 'proxy_auth_plugin.zip'
with zipfile.ZipFile(plugin_path, 'w') as zp:
    zp.writestr("manifest.json", manifest_json)
    zp.writestr("background.js", background_js)

# Starten von Chrome mit der Erweiterung
chrome_options = Options()
chrome_options.add_extension(plugin_path)

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()
os.remove(plugin_path)  # Temporäre Datei löschen

Methode 2: Firefox mit Authentifizierung (einfacher)

Firefox ermöglicht die Übertragung von Anmeldeinformationen über die Profileinstellungen:

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080
PROXY_USER = "username"
PROXY_PASS = "password"

firefox_options = Options()

firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# Authentifizierung (funktioniert nicht immer, abhängig von der Firefox-Version)
firefox_options.set_preference("network.proxy.username", PROXY_USER)
firefox_options.set_preference("network.proxy.password", PROXY_PASS)

# Deaktivierung der Authentifizierungsanfrage
firefox_options.set_preference("network.automatic-ntlm-auth.trusted-uris", PROXY_HOST)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Hinweis: Wenn Ihr Proxy-Anbieter Whitelisting von IPs unterstützt, ist es einfacher, die IP Ihres Servers auf die Whitelist zu setzen und den Proxy ohne Authentifizierung zu verwenden.

Proxy-Rotation in Selenium

Beim Scraping großer Datenmengen ist es entscheidend, Proxys zu wechseln, um Blockierungen zu vermeiden. Es gibt zwei Ansätze: Rotation auf Code-Ebene und die Verwendung von rotating Proxys.

Rotation auf Code-Ebene (Erstellung eines neuen Drivers)

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

# Liste der Proxys
PROXY_LIST = [
    "123.45.67.89:8080",
    "98.76.54.32:8080",
    "11.22.33.44:8080",
]

def create_driver_with_proxy(proxy):
    """Erstellung eines Drivers mit dem angegebenen Proxy"""
    chrome_options = Options()
    chrome_options.add_argument(f'--proxy-server=http://{proxy}')
    chrome_options.add_argument('--no-sandbox')
    return webdriver.Chrome(options=chrome_options)

# Scraping mit Rotation
urls_to_parse = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3',
]

for url in urls_to_parse:
    # Wählen Sie einen zufälligen Proxy
    current_proxy = random.choice(PROXY_LIST)
    
    # Erstellen Sie einen neuen Driver mit dem Proxy
    driver = create_driver_with_proxy(current_proxy)
    
    try:
        driver.get(url)
        # Ihre Scraping-Logik
        print(f"Parsed {url} via {current_proxy}")
        print(driver.title)
    except Exception as e:
        print(f"Error with {current_proxy}: {e}")
    finally:
        driver.quit()  # Wichtig: Driver schließen

Verwendung von rotating Proxys (einfacher)

Viele Proxy-Anbieter bieten einen rotating Endpoint — eine URL, die bei jeder Anfrage oder in bestimmten Intervallen automatisch die IP wechselt. Dies vereinfacht den Code:

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

# Rotating Proxy Endpoint (IP wechselt automatisch)
ROTATING_PROXY = "rotating.proxycove.com:8080"

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{ROTATING_PROXY}')

driver = webdriver.Chrome(options=chrome_options)

# Jede Anfrage erfolgt mit einer neuen IP
urls = ['https://httpbin.org/ip'] * 5

for url in urls:
    driver.get(url)
    print(driver.find_element("tag name", "body").text)
    # Jede Ausgabe zeigt eine andere IP

driver.quit()

Empfehlung: Für große Projekte verwenden Sie rotating Proxys — dies spart Ressourcen (kein erneutes Erstellen des Drivers erforderlich) und vereinfacht den Code. Residential Proxys unterstützen normalerweise die Rotation standardmäßig.

Typische Fehler und deren Lösungen

Fehler: "ERR_PROXY_CONNECTION_FAILED"

Ursache: Selenium kann keine Verbindung zum Proxy-Server herstellen.

Lösung:

Überprüfen Sie die Richtigkeit der IP und des Ports des Proxys
Stellen Sie sicher, dass der Proxy aktiv ist (überprüfen Sie mit curl: curl -x http://123.45.67.89:8080 https://httpbin.org/ip)
Überprüfen Sie die Firewall — möglicherweise sind ausgehende Verbindungen zum Proxy blockiert
Wenn Sie Authentifizierung verwenden, überprüfen Sie die Richtigkeit von Benutzername/Passwort

Fehler: "ERR_TUNNEL_CONNECTION_FAILED"

Ursache: Problem mit der HTTPS-Verbindung über den Proxy.

Lösung:

Stellen Sie sicher, dass der Proxy HTTPS unterstützt (CONNECT-Methode)
Verwenden Sie für HTTPS-Websites HTTPS-Proxys oder SOCKS5
Fügen Sie die Option zum Ignorieren von SSL-Fehlern hinzu: chrome_options.add_argument('--ignore-certificate-errors')

Fehler: Proxy funktioniert, aber die Website erkennt den Bot

Ursache: Die Website verwendet fortschrittliche Erkennungsmethoden (Fingerprinting, Verhaltensanalyse).

Lösung:

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

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{PROXY}')

# Deaktivierung des webdriver-Flags (Hauptmerkmal der Automatisierung)
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

driver = webdriver.Chrome(options=chrome_options)

# Entfernen von navigator.webdriver
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        })
    '''
})

driver.get('https://bot.sannysoft.com/')  # Website zur Überprüfung der Erkennung

Zusätzlich wird empfohlen, die Bibliothek undetected-chromedriver zu verwenden, die automatisch viele Anti-Detection-Techniken anwendet.

Problem: Langsame Seitenladezeiten über den Proxy

Ursache: Der Proxy ist überlastet oder geografisch weit entfernt.

Lösung:

Wählen Sie Proxys, die näher am Zielserver liegen (verwenden Sie beispielsweise US-Proxys für das Scraping von US-Websites)
Verwenden Sie Rechenzentrums-Proxys für Aufgaben, bei denen Geschwindigkeit wichtiger ist als Anonymität
Konfigurieren Sie Timeouts in Selenium, um Hängemöglichkeiten zu vermeiden:

from selenium.webdriver.support.ui import WebDriverWait

driver.set_page_load_timeout(30)  # Maximal 30 Sekunden für das Laden
driver.implicitly_wait(10)  # Implizite Wartezeit für Elemente

Best Practices bei der Arbeit mit Proxys

1. Verwenden Sie Proxy-Pools
Verlassen Sie sich nicht auf einen einzigen Proxy-Server. Erstellen Sie einen Pool aus 10-50 Proxys und rotieren Sie diese. Wenn ein Proxy gesperrt wird, kann das Scraping mit einem anderen fortgesetzt werden.

2. Fügen Sie zufällige Verzögerungen hinzu
Selbst mit Proxys wirken zu schnelle Anfragen verdächtig. Fügen Sie zufällige Verzögerungen von 2-5 Sekunden zwischen den Anfragen hinzu:

import time
import random

for url in urls:
    driver.get(url)
    # Scraping...
    time.sleep(random.uniform(2, 5))  # Zufällige Verzögerung von 2-5 Sekunden

3. Überwachen Sie die Qualität der Proxys
Überprüfen Sie Proxys vor der Verwendung. Schließen Sie solche aus, die nicht antworten oder Fehler zurückgeben:

import requests

def check_proxy(proxy):
    """Überprüfung der Funktionsfähigkeit des Proxys"""
    try:
        response = requests.get(
            'https://httpbin.org/ip',
            proxies={'http': f'http://{proxy}', 'https': f'http://{proxy}'},
            timeout=10
        )
        return response.status_code == 200
    except:
        return False

# Filtern von funktionierenden Proxys
working_proxies = [p for p in PROXY_LIST if check_proxy(p)]
print(f"Working proxies: {len(working_proxies)}/{len(PROXY_LIST)}")

4. Verwenden Sie den Headless-Modus mit Vorsicht
Headless-Browser sind leichter zu erkennen. Für komplexe Websites starten Sie den Browser im normalen Modus oder verwenden Sie --window-size anstelle von --headless.

5. Protokollieren Sie alle Anfragen
Speichern Sie Informationen darüber, welcher Proxy für jede Anfrage verwendet wurde. Dies hilft, problematische Proxys zu identifizieren und Fehler zu debuggen.

6. Halten Sie sich an robots.txt und Rate Limits
Selbst mit Proxys respektieren Sie die Regeln der Website. Aggressives Scraping kann zur Sperrung ganzer Subnetze von Proxys führen, was anderen Benutzern schadet.

Fazit

Die richtige Einrichtung von Proxys in Selenium WebDriver ist die Grundlage für stabiles Scraping und Automatisierung. Wir haben alle grundlegenden Methoden zur Integration von Proxys für Chrome und Firefox, den Umgang mit Authentifizierung, die Rotation von IP-Adressen und die Lösung typischer Probleme behandelt. Das Wichtigste ist, den passenden Proxy-Typ für Ihre Aufgabe auszuwählen: Für einfaches Scraping sind Rechenzentrums-Proxys ausreichend, während für die Arbeit mit geschützten Plattformen Residential oder mobile Proxys erforderlich sind.

Denken Sie an die Best Practices: Verwenden Sie Proxy-Pools, fügen Sie zufällige Verzögerungen hinzu, überwachen Sie die Qualität der Verbindungen und wenden Sie Anti-Detection-Techniken an. Dies erhöht die Stabilität Ihrer Skripte und verringert das Risiko von Blockierungen um ein Vielfaches.

Wenn Sie die Automatisierung von Scraping mit hohen Anforderungen an Anonymität und Umgehung von Anti-Bot-Systemen planen, empfehlen wir, Residential Proxys auszuprobieren — sie bieten maximale Stabilität bei der Arbeit mit allen Websites, einschließlich sozialer Netzwerke, E-Commerce-Plattformen und Diensten mit fortschrittlichem Schutz. Für Aufgaben, bei denen die Geschwindigkeit der Verarbeitung großer Datenmengen entscheidend ist, sind Rechenzentrums-Proxys die optimale Wahl im Hinblick auf Preis-Leistungs-Verhältnis.

```

Proxy-Einstellungen in Selenium WebDriver: Ultimative Anleitung mit Codebeispielen für Python und Java

Warum Proxys in Selenium benötigt werden

Welche Proxy-Typen verwendet werden sollten

Proxy-Einrichtung für Chrome in Selenium

Methode 1: HTTP/HTTPS-Proxys ohne Authentifizierung (Python)

Methode 2: SOCKS5-Proxys (Python)

Proxy-Einrichtung für Chrome in Java

Proxy-Einrichtung für Firefox in Selenium

HTTP/HTTPS-Proxys für Firefox (Python)

SOCKS5-Proxys für Firefox (Python)

Arbeiten mit Proxys, die Authentifizierung erfordern

Methode 1: Chrome-Erweiterung zur Authentifizierung (empfohlen)

Methode 2: Firefox mit Authentifizierung (einfacher)

Proxy-Rotation in Selenium

Rotation auf Code-Ebene (Erstellung eines neuen Drivers)

Verwendung von rotating Proxys (einfacher)

Typische Fehler und deren Lösungen

Fehler: "ERR_PROXY_CONNECTION_FAILED"

Fehler: "ERR_TUNNEL_CONNECTION_FAILED"

Fehler: Proxy funktioniert, aber die Website erkennt den Bot

Problem: Langsame Seitenladezeiten über den Proxy

Best Practices bei der Arbeit mit Proxys

Fazit