So richten Sie einen Proxy in Python Requests für Web Scraping, API und Automatisierung ein: umfassender Leitfaden mit Codebeispielen

Wenn Ihr Python-Skript einen Fehler 403, CAPTCHA oder eine IP-Sperre erhält, bedeutet das, dass die Zielwebsite Sie bereits bemerkt hat. Die Verbindung eines Proxys zur requests-Bibliothek löst dieses Problem: Sie ändern die IP-Adresse, umgehen geografische Einschränkungen und verteilen die Last auf mehrere Adressen. In diesem Leitfaden finden Sie alles von der grundlegenden Verbindung bis zur fortgeschrittenen Rotation mit realen Codebeispielen.

Warum Proxys in Python-Skripten benötigt werden

Die meisten Websites und APIs verfolgen die IP-Adressen eingehender Anfragen. Wenn eine Adresse 100+ Anfragen pro Minute sendet, wird sie blockiert. Dies ist ein Standard-Schutz gegen Bots, der von Wildberries, Ozon, Avito, Google, Instagram und Hunderten anderer Plattformen verwendet wird. Proxys ermöglichen es, die Anfrage über einen Zwischenserver mit einer anderen IP-Adresse zu leiten, wodurch Sie für die Schutzsysteme unsichtbar werden.

Hier sind die Hauptaufgaben, bei denen Proxys in Python kritisch notwendig sind:

• Scraping von Marktplätzen – Preisabfrage von Wildberries, Ozon, Yandex.Market ohne IP-Blockierungen
• Wettbewerbsüberwachung – regelmäßige Anfragen an die Websites der Wettbewerber alle 5–15 Minuten
• Arbeiten mit APIs mit Limits – Verteilung der Anfragen auf mehrere IPs, um das Rate Limit nicht zu überschreiten
• Geolokationstests – Überprüfung, wie die Website aus verschiedenen Ländern und Regionen aussieht
• Automatisierung von Formularen und Registrierungen – Erstellung von Konten oder Ausfüllung von Formularen von verschiedenen IPs
• SEO-Überwachung – Abfrage von Positionen aus verschiedenen Regionen Russlands und anderen Ländern

Ohne Proxys wird selbst ein gut geschriebener Scraper bereits nach wenigen Stunden auf eine Blockierung stoßen. Mit einer richtig konfigurierten IP-Rotation funktioniert dasselbe Skript wochenlang ohne Unterbrechung.

Grundlegende Proxy-Einrichtung in requests

Die requests-Bibliothek unterstützt Proxys nativ – es sind keine zusätzlichen Pakete erforderlich. Proxys werden über ein Dictionary proxies in die Anfrageparameter übergeben.

Das einfachste Beispiel – ein HTTP-Proxy für eine Anfrage:

import requests

proxies = {
    "http": "http://123.45.67.89:8080",
    "https": "http://123.45.67.89:8080",
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
# {'origin': '123.45.67.89'}
  

Bitte beachten Sie: Im Dictionary proxies müssen beide Schlüssel angegeben werden – http und https. Wenn nur einer angegeben wird, gehen die Anfragen über das andere Protokoll direkt ohne Proxy. Dies ist ein häufiger Fehler bei Anfängern, wodurch die echte IP dennoch durchdringt.

Um sicherzustellen, dass der Proxy funktioniert, verwenden Sie den Dienst httpbin.org/ip – er gibt die IP-Adresse zurück, von der die Anfrage kam. Wenn Sie in der Antwort die IP des Proxy-Servers sehen und nicht Ihre eigene, ist alles richtig konfiguriert.

HTTP, HTTPS und SOCKS5 Proxys: Unterschiede und Codebeispiele

Proxys gibt es in verschiedenen Typen, und jeder eignet sich für seine eigenen Aufgaben. Im Kontext von Python requests ist es wichtig, den Unterschied zwischen drei Hauptprotokollen zu verstehen:

Um mit SOCKS5 in Python zu arbeiten, müssen Sie ein zusätzliches Paket installieren:

pip install requests[socks]
# oder separat:
pip install PySocks
  

Nach der Installation sieht die Verbindung zu einem SOCKS5-Proxy so aus:

import requests

# SOCKS5 Proxy
proxies = {
    "http": "socks5://123.45.67.89:1080",
    "https": "socks5://123.45.67.89:1080",
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
  

SOCKS5 ist das bevorzugte Protokoll für Aufgaben, bei denen Anonymität wichtig ist. Im Gegensatz zu HTTP-Proxys fügt SOCKS5 keine X-Forwarded-For-Header hinzu, die Ihre echte IP offenbaren könnten.

Proxys mit Authentifizierung durch Benutzername und Passwort

Die meisten kostenpflichtigen Proxy-Dienste verwenden die Authentifizierung durch Benutzername und Passwort. Dies ist eine gängige Praxis – ohne Authentifizierung lässt der Proxy Ihre Anfrage einfach nicht durch. In der requests-Bibliothek werden die Authentifizierungsdaten direkt in der Proxy-URL übergeben.

import requests

# Format: protokoll://benutzername:passwort@host:port
proxy_url = "http://myuser:[email protected]:8080"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.status_code)
print(response.json())
  

Wenn im Passwort oder Benutzernamen Sonderzeichen enthalten sind (z. B. @, #, %), müssen diese URL-kodiert werden. Verwenden Sie dazu das Modul urllib.parse:

import requests
from urllib.parse import quote

username = "myuser"
password = "p@ss#word!"  # Sonderzeichen

# URL-kodieren von Benutzername und Passwort
encoded_user = quote(username, safe="")
encoded_pass = quote(password, safe="")

proxy_url = f"http://{encoded_user}:{encoded_pass}@123.45.67.89:8080"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
  

Proxy-Rotation: Automatischer IP-Wechsel für Scraping

Ein Proxy ist immer noch eine IP-Adresse, die blockiert werden kann. Der echte Schutz vor Sperren ist die Rotation: Jede Anfrage (oder jede N-Anfrage) wird mit einer neuen IP gesendet. Im Folgenden finden Sie einige Ansätze zur Implementierung der Rotation.

Methode 1: Zufällige Auswahl aus der Liste

import requests
import random

# Liste der Proxys
proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

def get_random_proxy():
    proxy = random.choice(proxy_list)
    return {"http": proxy, "https": proxy}

# Scraping von 10 Seiten mit IP-Rotation
urls = [f"https://example.com/page/{i}" for i in range(1, 11)]

for url in urls:
    proxies = get_random_proxy()
    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"URL: {url} | IP: {proxies['http'].split('@')[1]} | Status: {response.status_code}")
    except requests.RequestException as e:
        print(f"Fehler: {e}")
  

Methode 2: Zyklische Rotation mit itertools

import requests
import itertools

proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

# Erstellen eines unendlichen Zyklus über die Liste der Proxys
proxy_cycle = itertools.cycle(proxy_list)

def get_next_proxy():
    proxy = next(proxy_cycle)
    return {"http": proxy, "https": proxy}

# Jede Anfrage verwendet den nächsten Proxy im Kreis
for i in range(9):
    proxies = get_next_proxy()
    response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
    print(f"Anfrage {i+1}: {response.json()['origin']}")
  

Für industrielle Aufgaben mit Tausenden von Anfragen pro Stunde wird empfohlen, residential Proxys mit integrierter automatischer Rotation zu verwenden – der Anbieter wechselt die IP für jede Anfrage über einen einzigen Endpunkt, und Sie müssen die Liste der Adressen nicht manuell verwalten.

Proxys über Session: Ständige Verbindungen und Cookies

Wenn mehrere Anfragen innerhalb einer Sitzung gemacht werden müssen (z. B. um sich anzumelden und dann Anfragen zu stellen), verwenden Sie das Objekt requests.Session(). Es speichert Cookies, Header und Proxy-Einstellungen zwischen den Anfragen – es ist nicht erforderlich, den Proxy bei jedem Aufruf separat zu übergeben.

import requests

# Erstellen einer Sitzung mit Proxy
session = requests.Session()
session.proxies = {
    "http": "http://user:[email protected]:8080",
    "https": "http://user:[email protected]:8080",
}

# Hinzufügen von Headern zur Simulation eines Browsers
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Accept-Language": "de-DE,de;q=0.9",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
})

# Schritt 1: Authentifizierung
login_data = {"username": "myuser", "password": "mypass"}
session.post("https://example.com/login", data=login_data)

# Schritt 2: Anfragen bereits mit Cookies und über Proxy
response = session.get("https://example.com/dashboard")
print(response.status_code)

# Schritt 3: Sitzung schließen
session.close()
  

Die Verwendung von Session ist auch hinsichtlich der Leistung effizienter: Die TCP-Verbindung wird wiederverwendet, anstatt für jede Anfrage neu geöffnet zu werden. Beim Scraping von 1000+ Seiten führt dies zu einem spürbaren Geschwindigkeitszuwachs.

Fehler-, Timeout- und automatische Wiederholungsbehandlung

Proxy-Server können nicht verfügbar sein, langsam antworten oder Verbindungsfehler zurückgeben. Ein zuverlässiges Scraping-Skript sollte in der Lage sein, diese Situationen zu behandeln und automatisch auf einen anderen Proxy bei einem Fehler umzuschalten.

import requests
import random
import time

proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

def fetch_with_retry(url, max_retries=3, timeout=10):
    """
    Führt eine Anfrage mit automatischem Proxy-Wechsel bei Fehlern durch.
    Gibt das Response-Objekt oder None zurück, wenn die Versuche erschöpft sind.
    """
    available_proxies = proxy_list.copy()
    random.shuffle(available_proxies)

    for attempt, proxy_url in enumerate(available_proxies[:max_retries], 1):
        proxies = {"http": proxy_url, "https": proxy_url}
        try:
            response = requests.get(
                url,
                proxies=proxies,
                timeout=timeout,
                headers={"User-Agent": "Mozilla/5.0"}
            )
            response.raise_for_status()  # Wirft eine Ausnahme bei 4xx/5xx
            print(f"✓ Erfolg beim Versuch {attempt}")
            return response

        except requests.exceptions.ProxyError:
            print(f"✗ Versuch {attempt}: Proxy nicht verfügbar — {proxy_url}")
        except requests.exceptions.Timeout:
            print(f"✗ Versuch {attempt}: Timeout — {proxy_url}")
        except requests.exceptions.HTTPError as e:
            print(f"✗ Versuch {attempt}: HTTP-Fehler {e.response.status_code}")
            if e.response.status_code == 403:
                print("  → Sperre erhalten, versuchen wir den nächsten Proxy...")
        except requests.exceptions.RequestException as e:
            print(f"✗ Versuch {attempt}: allgemeiner Fehler — {e}")

        time.sleep(1)  # Pause zwischen den Versuchen

    print(f"✗ Alle {max_retries} Versuche für {url} erschöpft")
    return None

# Verwendung
result = fetch_with_retry("https://httpbin.org/ip")
if result:
    print(result.json())
  

Beachten Sie raise_for_status() – diese Methode wirft automatisch eine Ausnahme bei HTTP-Status 4xx und 5xx. Ohne sie würde das Skript auch eine Antwort mit dem Code 403 (Sperre) oder 429 (Anfragenlimit überschritten) als erfolgreich betrachten.

Proxys über Umgebungsvariablen: Sichere Datenspeicherung

Die requests-Bibliothek liest automatisch die Umgebungsvariablen HTTP_PROXY und HTTPS_PROXY. Dadurch müssen keine Anmeldedaten im Code gespeichert werden, und es ist einfach, zwischen Proxys zu wechseln, ohne das Skript zu ändern.

Umgebungsvariablen im Terminal festlegen (Linux/macOS):

export HTTP_PROXY="http://user:[email protected]:8080"
export HTTPS_PROXY="http://user:[email protected]:8080"
export NO_PROXY="localhost,127.0.0.1"
  

Oder über eine Datei .env mit der Bibliothek python-dotenv:

# Datei .env (in .gitignore hinzufügen!)
HTTP_PROXY=http://user:[email protected]:8080
HTTPS_PROXY=http://user:[email protected]:8080
  

# Python-Skript
from dotenv import load_dotenv
import requests
import os

load_dotenv()  # Lädt Variablen aus .env

# requests verwendet automatisch HTTP_PROXY und HTTPS_PROXY
response = requests.get("https://httpbin.org/ip")
print(response.json())

# Oder explizit aus den Umgebungsvariablen:
proxies = {
    "http": os.getenv("HTTP_PROXY"),
    "https": os.getenv("HTTPS_PROXY"),
}
response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
  

Reale Szenarien: Scraping von Marktplätzen, Arbeiten mit APIs und Automatisierung

Lassen Sie uns drei praktische Szenarien betrachten, mit denen Entwickler häufig konfrontiert werden.

Szenario 1: Preisabfrage von einem Marktplatz

Bei der Überwachung von Preisen auf Wildberries oder Ozon ist es wichtig, das Verhalten eines echten Benutzers zu simulieren: die richtigen Browser-Header zu übergeben, Verzögerungen zwischen den Anfragen hinzuzufügen und die IP zu rotieren. Für diese Aufgabe eignen sich Datacenter-Proxys gut – sie sind schnell und kostengünstig bei der Verarbeitung großer Datenmengen.

import requests
import time
import random

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Accept": "application/json, text/plain, */*",
    "Accept-Language": "de-DE,de;q=0.9",
    "Referer": "https://www.wildberries.ru/",
}

PROXIES = [
    {"http": "http://user:[email protected]:8080",
     "https": "http://user:[email protected]:8080"},
    {"http": "http://user:[email protected]:8080",
     "https": "http://user:[email protected]:8080"},
]

def get_product_price(article_id: int) -> dict:
    """Erhält den Preis eines Produkts anhand der Artikelnummer von Wildberries."""
    url = f"https://card.wb.ru/cards/v1/detail?appType=1&curr=rub&nm={article_id}"
    proxies = random.choice(PROXIES)

    try:
        resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=15)
        resp.raise_for_status()
        data = resp.json()
        product = data["data"]["products"][0]
        return {
            "id": product["id"],
            "name": product["name"],
            "price": product["salePriceU"] / 100,  # Preis in Kopeken
        }
    except (requests.RequestException, KeyError, IndexError) as e:
        return {"error": str(e)}

# Abfrage mehrerer Artikel mit Verzögerung
articles = [12345678, 87654321, 11223344]
for article in articles:
    result = get_product_price(article)
    print(result)
    time.sleep(random.uniform(1.5, 3.0))  # Zufällige Verzögerung 1.5-3 Sek
  

Szenario 2: Arbeiten mit APIs über Proxys

Einige APIs beschränken die Anzahl der Anfragen von einer IP (Rate Limiting). Die Verteilung der Anfragen auf mehrere Proxys ermöglicht es, diese Einschränkung zu umgehen:

import requests
import itertools
from typing import Optional

class ProxyAPIClient:
    """Client zur Arbeit mit APIs über Proxy-Rotation."""

    def __init__(self, api_key: str, proxy_list: list):
        self.api_key = api_key
        self.proxy_cycle = itertools.cycle(proxy_list)
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        })

    def _get_proxy(self) -> dict:
        proxy = next(self.proxy_cycle)
        return {"http": proxy, "https": proxy}

    def get(self, url: str, **kwargs) -> Optional[dict]:
        proxies = self._get_proxy()
        try:
            resp = self.session.get(url, proxies=proxies, timeout=10, **kwargs)
            resp.raise_for_status()
            return resp.json()
        except requests.RequestException as e:
            print(f"API-Anfrage fehlgeschlagen: {e}")
            return None

# Verwendung
proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

client = ProxyAPIClient(api_key="your_api_key", proxy_list=proxy_list)
data = client.get("https://api.example.com/products")
  

Szenario 3: Geolokationstests

Marketing- und SEO-Spezialisten überprüfen häufig, wie eine Website aus verschiedenen Regionen aussieht. Mit Proxys aus den gewünschten Standorten kann dieser Prozess automatisiert werden:

import requests

# Proxys aus verschiedenen Regionen
regional_proxies = {
    "Moskau":        "http://user:[email protected]:8080",
    "Sankt Petersburg": "http://user:[email protected]:8080",
    "Nowosibirsk":   "http://user:[email protected]:8080",
    "USA":           "http://user:[email protected]:8080",
}

url = "https://example.com/prices"

for region, proxy_url in regional_proxies.items():
    proxies = {"http": proxy_url, "https": proxy_url}
    try:
        resp = requests.get(url, proxies=proxies, timeout=15)
        print(f"[{region}] Status: {resp.status_code} | "
              f"Größe: {len(resp.content)} Bytes")
    except requests.RequestException as e:
        print(f"[{region}] Fehler: {e}")
  

Welchen Proxy-Typ für Ihre Aufgabe wählen

Die Wahl des Proxy-Typs hat direkten Einfluss auf den Erfolg Ihres Projekts. Ein günstiger Datacenter-Proxy kann für bestimmte Aufgaben hervorragend funktionieren und für andere völlig versagen. Hier ist ein praktischer Leitfaden zur Auswahl:

Für Aufgaben, bei denen maximale Zuverlässigkeit und minimales Risiko einer Sperre bei der Arbeit mit geschützten Websites wichtig sind, wählen Entwickler am häufigsten mobile Proxys – sie verwenden IP-Adressen realer Mobilfunkanbieter (MTS, Beeline, MegaFon), die extrem selten auf Blocklisten geraten.

Checkliste zur Überprüfung von Proxys vor der Verwendung

• ✅ Überprüfen Sie die IP über httpbin.org/ip – ist Ihre echte Adresse sichtbar?
• ✅ Überprüfen Sie die Geschwindigkeit – die Antwortzeit sollte 2-3 Sekunden nicht überschreiten
• ✅ Stellen Sie sicher, dass der Proxy nicht auf Blocklisten steht über blocklist.de oder ipqualityscore.com
• ✅ Überprüfen Sie die Geolokation über ipinfo.io – stimmt sie mit der erwarteten Region überein?
• ✅ Testen Sie auf der Zielwebsite mit einer Anfrage, bevor Sie das vollständige Skript ausführen
• ✅ Stellen Sie sicher, dass der HTTPS-Verkehr ebenfalls über den Proxy läuft (beide Schlüssel im Dictionary)

Fazit

Die Einrichtung von Proxys in Python requests ist nicht schwierig, erfordert jedoch Aufmerksamkeit für Details. Die wichtigsten Prinzipien, die Sie sich merken sollten: Geben Sie immer beide Schlüssel (http und https) im Proxy-Dictionary an, verwenden Sie Session für mehrstufige Szenarien, behandeln Sie unbedingt Fehler und Timeouts, und speichern Sie Anmeldedaten in Umgebungsvariablen und nicht im Code.

Für industrielles Scraping mit Tausenden von Anfragen pro Tag reicht eine manuelle Liste von Proxys nicht aus – Rotation ist erforderlich. Wenn Sie geschützte Marktplätze wie Wildberries oder Ozon scrapen, mit sozialen Netzwerken arbeiten oder Geolokationstests durchführen, empfehlen wir, residential Proxys auszuprobieren – sie bieten ein hohes Maß an Vertrauen seitens der Anti-Bot-Systeme und unterstützen die automatische IP-Rotation über einen einzigen Endpunkt, was den Code Ihres Skripts erheblich vereinfacht.