Wie man Proxys in Python rotiert

In diesem Leitfaden zum Rotieren von Proxys in Python lernen Sie:

• Was Proxys sind und warum man sie verwendet
• Was Proxy-Rotation ist und warum Sie sie brauchen könnten
• Wie man Proxys in Python rotiert
• Häufige Einschränkungen beim Rotieren von Proxys in Python

Legen wir los!

Was ist ein Proxy?

Ein Proxy ist ein Server, der als Vermittler zwischen einem Nutzer und einer Netzwerkressource über das Internet fungiert. Man kann sich einen Proxy also als Mittelsmann vorstellen, der Anfragen und Antworten zwischen Parteien weiterleitet.

Warum Proxys in Python verwenden?

Wenn Sie eine Anfrage mit einem Proxy an eine Website senden, läuft die Anfrage zunächst durch den Proxy-Server. Dann leitet der Proxy Ihre Anfrage an die Website weiter, empfängt die Antwort und sendet sie an Sie zurück. Dieser Vorgang verschleiert Ihre IP-Adresse gegenüber dem Ziel, sodass es so aussieht, als käme die Anfrage vom Proxy-Server und nicht von Ihrem Gerät.

Der typische Grund, warum man einen Proxy verwenden möchte, ist die Automatisierung von Webanfragen oder Web-Scraping. In diesem Szenario ist Python eine der besten Sprachen für Web-Scraping, dank seiner umfangreichen Bibliotheken und seiner großen, aktiven Community.

Was ist Proxy-Rotation und warum braucht man sie?

Wenn Sie zu viele Anfragen von einer einzigen IP-Adresse senden, können Websites Sie durch Rate Limiting oder direkte IP-Sperren blockieren. Hier hilft die Proxy-Rotation über Proxys weiter.

Das systematische Wechseln zwischen verschiedenen Proxy-Servern bei Webanfragen ist eine der besten Methoden, um IP-Adressrotation umzusetzen. Dieses Verfahren hilft Ihnen, gängige Anti-Scraping-Techniken zu umgehen, und bietet Ihnen folgende Vorteile:

• Vermeidung von IP-Sperren: Verteilen Sie Anfragen auf mehrere IPs, sodass es Websites schwerer fällt, Ihre Scraping-Aktivität zu erkennen und zu blockieren.
• Umgehung von Rate Limits: Websites setzen oft Anfragelimits pro IP-Adresse innerhalb eines bestimmten Zeitraums. Rotierende Proxys helfen Ihnen, auch nach Erreichen dieser Limits auf einer IP weiter zu scrapen.
• Zugriff auf geobeschränkte Inhalte: Manche Websites zeigen je nach geografischem Standort unterschiedliche Inhalte. Proxy-Rotation mit Proxys aus verschiedenen Ländern ermöglicht Ihnen den Zugriff auf standortspezifische Inhalte.

Wie man Proxys in Python rotiert: 3 Ansätze

Nun, da Sie wissen, was Proxys sind und warum man sie rotiert, sind Sie bereit für einige Schritt-für-Schritt-Anleitungen in Python. Die nächsten Abschnitte zeigen Ihnen, wie man Proxys in Python mit verschiedenen Ansätzen und Bibliotheken rotiert.

Die Zielseite für alle Skripte ist der /ip-Endpunkt des HTTPBin-Projekts. Dieser spezielle Endpunkt gibt die IP-Adresse des Aufrufers zurück, was ihn ideal macht, um zu testen, ob die vom Server gesehene IP rotiert.

Zeit, einige Proxys in Python zu rotieren!

Voraussetzungen

Um die Tutorials zur Proxy-Rotation mit Python nachzubilden, müssen Sie Python 3.7 oder höher auf Ihrem Rechner installiert haben.

Vorbereitungen

Angenommen, Sie nennen den Hauptordner Ihres Projekts proxy_rotation/. Am Ende dieses Schritts hat der Ordner folgende Struktur:

proxy_rotation/
    ├── requests_file.py
    ├── async.py
    ├── scrapy_rotation/
    └── venv/ 

Wobei:

• requests.py und async.py Python-Dateien sind, die die Rotationslogik für Requests bzw. AIOHTTP speichern.
• scrapy_rotation/ ein Ordner ist, der ein Scrapy-Projekt enthält. Sie werden es später erstellen und instanziieren.
• venv/ die virtuelle Umgebung enthält

Sie können das Verzeichnis der venv/ virtuellen Umgebung wie folgt erstellen:

python -m venv venv

Um sie unter Windows zu aktivieren, führen Sie aus:

venvScriptsactivate

Unter macOS und Linux entsprechend mit:

source venv/bin/activate

Als letzte Voraussetzung müssen Sie eine Liste von Proxys abrufen. Für diesen Artikel können Sie unsere Liste kostenloser Proxys verwenden.

Wie man Proxys in Python mit Requests rotiert

In diesem Tutorial-Abschnitt lernen Sie, wie man Proxys in Python mit Requests rotiert.

Schritt #1: Abhängigkeiten installieren

Installieren Sie in der aktivierten virtuellen Umgebung Requests mit:

pip install requests

Schritt #2: Die Rotationslogik definieren

Um Proxys in Python mit Requests zu rotieren, schreiben Sie folgenden Code in die Datei requests_file.py:

import random
import requests

# Liste von Proxys definieren und einen zufälligen zurückgeben
def get_random_proxy():
    proxies = [
        "http://PROXY_1:PORT_X",
        "http://PROXY_2:PORT_Y",
        "http://PROXY_3:PORT_X",
        # Weitere Proxys hier hinzufügen...
    ]

    # Zufällig einen Proxy auswählen
    return random.choice(proxies)

for i in range(3):
    proxy_url = get_random_proxy()
    proxies = {
        "http": proxy_url,
        "https": proxy_url,
    }
    response = requests.get("https://httpbin.io/ip", proxies=proxies)
    print(response.text)

Wobei:

• Die Funktion get_random_proxy() die von Ihnen abgerufene Liste von Proxys speichert und mit der Methode random.choice() einen zufälligen zurückgibt.
• Die for-Schleife die randomisierte Liste von Proxys durchläuft und die eigentliche Anfrage mit der Methode requests.get() stellt. Weitere Informationen finden Sie in unserem Leitfaden zur Verwendung eines Proxys mit Python Requests.

Schritt #3: Das Skript starten

Um das Skript zu starten, führen Sie aus:

python requests_file.py

Nachfolgend die erwartete Antwort:

{
  "origin": "PROXY_3:PORT_K"
}
{
  "origin": "PROXY_1:PORT_N"
}
{
  "origin": "PROXY_2:PORT_P"
}

Wunderbar! Die Exit-IPs Ihres Skripts wurden wie gewünscht rotiert.

Wie man Proxys in Python mit AIOHTTP rotiert

Die Hauptbeschränkung des randomisierten Ansatzes mit der Requests-Bibliothek besteht darin, dass jeweils nur ein Proxy verwendet wird. Das bedeutet, dass Sie warten müssen, bis jede Anfrage abgeschlossen ist, bevor der nächste Proxy verwendet wird.

Um diese Einschränkung zu vermeiden, können Sie AIOHTTP verwenden. Diese Bibliothek ermöglicht es Ihnen, asynchrone Anfragen zu stellen und somit mehrere Proxys gleichzeitig nicht-blockierend zu nutzen. Mit anderen Worten erlaubt sie Ihnen, die Proxys aus Ihrer Liste durch asynchrone, parallele Anfragen an den Zielserver zu rotieren. Sehen Sie AIOHTTP in Aktion in unserem Leitfaden zum asynchronen Web-Scraping.

Der folgende Abschnitt zeigt, wie man Proxys in Python mit AIOHTTP rotiert.

Schritt #1: Abhängigkeiten installieren

Installieren Sie in der aktivierten virtuellen Umgebung AIOHTTP mit:

pip install aiohttp

Schritt #2: Die Rotationslogik definieren

Um Proxys in Python mit AIOHTTP zu rotieren, schreiben Sie folgenden Code in die Datei async.py:

import asyncio
import aiohttp

# Liste von Proxys definieren
proxies_list = [
    "http://PROXY_1:PORT_X",
    "http://PROXY_2:PORT_Y",
    "http://PROXY_3:PORT_X",
    # Weitere Proxys hier hinzufügen...
]

async def fetch_ip(session, proxy_address, attempt):
    print(f"Versuch {attempt} mit Proxy: {proxy_address}")
    async with session.get("https://httpbin.io/ip", proxy=proxy_address) as response:
        json_response = await response.json()
        print(f"Antwort von httpbin.io/ip (Versuch {attempt}):")
        print(f"IP-Adresse: {json_response.get('origin', 'Unbekannt')}")
        print("-" * 40)
        return json_response

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = []
        num_attempts = 3
        for i in range(num_attempts):
            # Proxys mit dem Modulo-Operator rotieren.
            proxy_address = proxies_list[i % len(proxies_list)]
            tasks.append(fetch_ip(session, proxy_address, i + 1))
        # Alle Anfragen gleichzeitig ausführen
        await asyncio.gather(*tasks)

# Das Skript starten
asyncio.run(main())

Dieser Code macht Folgendes:

• Die Funktion fetch_ip() verwaltet die Anfragen, indem sie die Session, einen Proxy und die Versuchsnummer entgegennimmt. Insbesondere sendet sie eine GET-Anfrage an die Zielwebsite und gibt die Antwort aus.
• Die Funktion main():
  • Erstellt mit der Methode aiohttp.ClientSession() eine Session zur Verwaltung von HTTP-Verbindungen.
  • Richtet eine Liste von Aufgaben ein, um mehrere Anfragen gleichzeitig zu senden, sowie die Anzahl der Versuche.
  • Rotiert die Proxys mithilfe des Modulo-Operators (i % len(proxies_list)), um sicherzustellen, dass Proxys im Round-Robin-Verfahren wiederverwendet werden, wenn die Anzahl der Anfragen die Anzahl der Proxys übersteigt. Erfahren Sie mehr in unserem Tutorial zum Einrichten eines Proxys in AIOHTTP.
  • Verwendet die Methode asyncio.gather(), um alle Aufgaben gleichzeitig auszuführen.

Schritt #3: Das Skript starten

Um das Skript zu starten, führen Sie aus:

python async.py

Dies ist die erwartete Antwort:

Versuch 1 mit Proxy: http://PROXY_1:PORT_X
Versuch 2 mit Proxy: http://PROXY_2:PORT_Y
Versuch 3 mit Proxy: http://PROXY_3:PORT_Z

Antwort von httpbin.io/ip (Versuch 3):
IP-Adresse: xxx.xxx.xxx.xxx
----------------------------------------
Antwort von httpbin.io/ip (Versuch 1):
IP-Adresse: yyy.yyy.yyy.yyy
----------------------------------------
Antwort von httpbin.io/ip (Versuch 2):
IP-Adresse: zzz.zzz.zzz.zzz
----------------------------------------

Fantastisch! Die IPs werden wie erwartet rotiert.

Wie man Proxys mit Python Scrapy rotiert

In einem früheren Artikel haben wir die Möglichkeit besprochen, Proxys in Python mit Scrapy mithilfe von scrapy-rotating-proxies zu rotieren.

In diesem geführten Abschnitt lernen Sie, wie das geht!

Schritt #1: Abhängigkeiten installieren

Installieren Sie in der aktivierten virtuellen Umgebung die notwendigen Bibliotheken:

pip install scrapy scrapy-rotating-proxies

Schritt #2: Ein neues Scrapy-Projekt erstellen

Instanziieren Sie im Hauptordner Ihres Repositorys (proxy_rotation/) ein neues Scrapy-Projekt mit diesem Befehl:

scrapy startproject scrapy_rotation

Dies erstellt einen neuen Unterordner namens scrapy_rotation/ mit folgender Struktur:

scrapy_rotation/
  ├── scrapy_rotation/ 
  │   ├── __init__.py
  │   ├── items.py # Definiert die Datenstruktur für gescrapte Elemente
  │   ├── middlewares.py # Benutzerdefinierte Middlewares
  │   ├── pipelines.py # Verwaltet die Nachbearbeitung gescrapter Daten
  │   ├── settings.py # Projekteinstellungen
  │   └── spiders/ # Ordner für alle Spider
  └── scrapy.cfg # Scrapy-Konfigurationsdatei

Wechseln Sie vom Hauptordner (proxy_rotation/) in den Ordner scrapy_rotation/:

cd scrapy_rotation

Sie können nun einen neuen Spider erstellen, der auf die Zielwebsite zeigt, indem Sie ausführen:

scrapy genspider rotation http://httpbin.io/ip

Dieses Skript erstellt auch die Datei rotation.py im Ordner spiders/.

Schritt #3: Die Rotationslogik definieren

Die Logik der Proxy-Rotation kann verwaltet werden, indem die Datei settings.py mit folgenden Einstellungen geändert wird:

# Die Rotating-Proxies-Middleware aktivieren
DOWNLOADER_MIDDLEWARES = {
    "rotating_proxies.middlewares.RotatingProxyMiddleware": 610,
    "rotating_proxies.middlewares.BanDetectionMiddleware": 620,
}

# Liste der zu rotierenden Proxys
ROTATING_PROXY_LIST = [
    "http://PROXY_1:PORT_X",
    "http://PROXY_2:PORT_Y",
    "http://PROXY_3:PORT_Z",
    # Weitere Proxys nach Bedarf hinzufügen
]

# Wiederholungseinstellungen konfigurieren
RETRY_TIMES = 5  # Anzahl der Wiederholungen für fehlgeschlagene Anfragen
RETRY_HTTP_CODES = [500, 502, 503, 504, 408]  # Zu wiederholende HTTP-Codes

Verantwortlich für die Proxy-Rotation ist hier die Option rotating_proxies.middlewares.RotatingProxyMiddleware: 610 in DOWNLOADER_MIDDLEWARES. Diese Option wählt insbesondere einen Proxy aus der ROTATING_PROXY_LIST aus und weist ihn jeder Anfrage zu.

Außerdem ermöglicht die Option rotating_proxies.middlewares.BanDetectionMiddleware: 620 dem Scraper zu erkennen, ob eine IP von der Zielwebsite gesperrt oder blockiert wurde. Falls eine Anfrage aus diesem Grund fehlschlägt, wiederholt die Middleware die Anfrage mit einem neuen Proxy. Diese Option arbeitet also eng mit der RotatingProxyMiddleware zusammen, um sicherzustellen, dass gesperrte Proxys automatisch vermieden werden.

Nun können Sie in der Datei rotation.py im Ordner spiders/ Folgendes schreiben:

import scrapy

class IpSpider(scrapy.Spider):
    name = "ip_spider"
    start_urls = ["http://httpbin.io/ip"]
    def parse(self, response):
        # Die IP-Adresse aus der Antwort extrahieren und ausgeben
        ip = response.json().get("origin")
        self.log(f"IP-Adresse: {ip}")

Diese Klasse instanziiert den gesamten Spider und gibt bei jeder Anfrage die Antwort aus.

Schritt #4: Das Skript starten

Um das Skript zu starten, müssen Sie den Namen der Klasse IpSpider() verwenden—nämlich ip_spider:

scrapy crawl ip_spider

Die von Scrapy in der CLI zurückgegebenen Daten sind besonders vollständig. Wenn also alles gut lief, finden Sie unter anderem Informationen wie diese:

2026-02-18 14:55:17 [rotating_proxies.expire] DEBUG: Proxy <http://PROXY_1:PORT_X> is GOOD
2026-02-18 14:55:17 [scrapy.core.engine] DEBUG: Crawled (200) <GET http://httpbin.io/robots.txt> (referer: None)
2026-02-18 14:55:24 [rotating_proxies.middlewares] INFO: Proxies(good: 1, dead: 0, unchecked: 2, reanimated: 0, mean backoff time: 0s)

Einschränkungen der oben genannten Ansätze zur Proxy-Rotation in Python

Die oben genannten Methoden zur Proxy-Rotation sind nützlich, bringen jedoch einige Einschränkungen mit sich:

• Sie erfordern, dass Sie manuell eine Liste von Proxys abrufen und verwalten.
• Sie beinhalten Boilerplate-Code.
• Sie können trotzdem zu IP-Sperren führen, wenn Sie keine hochwertigen Proxy-Server verwenden.

Wenn Sie nach einer effizienteren und effektiveren Möglichkeit suchen, die Proxy-Rotation in Python zu handhaben, bietet Bright Data einige der besten rotierenden Proxys auf dem Markt. Mit nur einer einzigen Proxy-URL können Sie diese in Ihren HTTP-Client oder Ihre Scraping-Bibliothek integrieren. Das macht Boilerplate-Code und manuelle Rotationsverwaltung überflüssig.

Weitere wichtige Vorteile dieses Ansatzes sind:

• Automatische IP-Rotation mit konfigurierbaren Sticky-IPs
• Zugriff auf 400M+ monthly Millionen Residential-IPs
• Geolokalisierungskontrolle über die Standorte der Proxy-Server
• Unterstützung für HTTP-, HTTPS- und SOCKS-Protokolle

Vereinfachen Sie Ihr Proxy-Management—entdecken Sie unsere automatisch rotierenden Proxys!

Fazit

In diesem Artikel haben Sie gelernt, wie man Proxys in Python mit drei verschiedenen Bibliotheken rotiert: Requests, AIOHTTP und Scrapy. Wie in den geführten Abschnitten oben gezeigt, ist der Prozess nicht kompliziert und erfordert nur wenige Codezeilen.

Dieser Ansatz hat jedoch einige Nachteile:

• Der Code ist stark von Boilerplate geprägt, was Ihr Skript weniger wartbar macht.
• Sie müssen eine große Liste von Proxy-Servern verwalten und den Zugriff darauf bereitstellen.

Glücklicherweise können Sie all diesen Aufwand mit den automatisch rotierenden Proxys von Bright Data überspringen—einer effizienteren Lösung zum Rotieren von Proxys in Python.

Bright Data betreibt die besten Proxy-Server der Welt und bedient Fortune-500-Unternehmen sowie 50,000+ Kunden. Das Angebot umfasst eine breite Palette von Proxy-Typen:

• Datacenter-Proxys – Über 1,300,000+ Datacenter-IPs.
• Residential-Proxys – Über 400M+ monthly Residential-IPs in mehr als 195 Ländern.
• ISP-Proxys – Über 1,300,000+ ISP-IPs.

Erstellen Sie noch heute ein Bright Data-Konto, um unsere Proxys und Scraping-Lösungen zu testen!