IP-Adressrotation: So wechseln Sie Proxys – Anleitung und Vorteile

Anfrage 1 → Proxy A (185.45.12.34) → Website sieht 185.45.12.34
Anfrage 2 → Proxy B (92.118.45.78) → Website sieht 92.118.45.78
Anfrage 3 → Proxy C (178.62.91.22) → Website sieht 178.62.91.22
Anfrage 4 → Proxy A (185.45.12.34) → Website sieht 185.45.12.34

1. Umgehung von Rate Limiting (Anfragelimits)

Die meisten Websites begrenzen die Anzahl der Anfragen von einer IP pro Zeiteinheit. Eine API erlaubt beispielsweise nur 100 Anfragen pro Stunde von einer IP. Durch die Rotation von 10 IP-Adressen können Sie 1.000 Anfragen pro Stunde senden, indem Sie die Last verteilen.

2. Vermeidung von IP-Bans beim Scraping

Beim Sammeln großer Datenmengen (E-Commerce-Scraping, Preisüberwachung, Kontaktdatenerfassung) führen häufige Anfragen von einer IP schnell zur Sperrung. Die Rotation ermöglicht es, Anfragen so zu verteilen, dass jede IP nur wenige Anfragen pro Stunde stellt – wie ein normaler Benutzer.

3. Umgehung geografischer Sperren

Viele Dienste zeigen unterschiedliche Inhalte oder Preise basierend auf der Geolokalisierung an. Die Rotation von Proxys aus verschiedenen Ländern ermöglicht das Sammeln von Daten aus allen Regionen, ohne physisch dort präsent sein zu müssen.

4. Verschleierung der Automatisierung

Schutzsysteme (Cloudflare, Akamai, PerimeterX) analysieren Verhaltensmuster. Wenn Hunderte von Anfragen in kurzer Zeit von einer IP kommen, ist dies ein klares Zeichen für einen Bot. Die Rotation hilft, die Illusion vieler unabhängiger Benutzer zu erzeugen.

5. Wettbewerbsanalyse

Die Verfolgung von Wettbewerbspreisen, die Überwachung von Werbekampagnen und die Analyse von SEO-Positionen erfordern häufige Überprüfungen. Die IP-Rotation ermöglicht das unbemerkte Sammeln dieser Daten, ohne die Aufmerksamkeit der Wettbewerber zu erregen.

6. Testen und Überwachung

Die Überprüfung der Website-Verfügbarkeit aus verschiedenen Regionen, das Testen von A/B-Experimenten, die Überwachung von SEO-Positionen in verschiedenen Ländern – all dies erfordert die Nutzung von IP-Adressen aus unterschiedlichen Standorten.

1. Rate Limiting (Analyse der Anfragenfrequenz)

Websites verfolgen die Anzahl der Anfragen von einer bestimmten IP über einen bestimmten Zeitraum. Typische Schwellenwerte sind:

• Konservative Websites: 10–30 Anfragen pro Minute
• Mittlere Websites: 50–100 Anfragen pro Minute
• API-Dienste: 100–1000 Anfragen pro Stunde (oft in der Dokumentation angegeben)

2. IP-Reputationsanalyse

Es gibt umfangreiche Datenbanken, die IP-Adressen nach Typen klassifizieren:

• Residential IP — Heim-Internetdienstanbieter (hohe Reputation)
• Datacenter IP — Server von Hosting-Unternehmen (verdächtig)
• Mobile IP — Mobilfunkanbieter (hohe Reputation)
• Known proxy IP — Bekannte Proxy-Server (werden oft blockiert)

3. Browser-Fingerprinting

Selbst bei wechselnder IP können Schutzsysteme Anfragen anhand des einzigartigen Browser-"Fingerabdrucks" verknüpfen: Bildschirmauflösung, installierte Schriftarten, Plugins, WebGL-Fingerprint, Canvas-Fingerprint, Audio-Context-Fingerprint.

4. Verhaltensanalyse

Moderne Anti-Bot-Systeme analysieren das Verhalten:

• Scroll-Geschwindigkeit der Seite
• Mausbewegungen
• Klickmuster
• Zeit zwischen Aktionen
• Reihenfolge der Seitenbesuche

5. TLS-Fingerprinting

Bei einer HTTPS-Verbindung kann der Server die TLS-Version, die verwendeten Cipher Suites und Erweiterungen identifizieren – diese Daten bilden einen einzigartigen Fingerabdruck, der zur Verfolgung selbst bei IP-Wechsel genutzt werden kann.

Typische Rotationsintervalle:

• Alle 5 Minuten — für intensives Scraping mit hoher Anfragenfrequenz
• Alle 10–15 Minuten — Standardmodus für die meisten Aufgaben
• Alle 30–60 Minuten — für Aufgaben mit geringer Anfragenfrequenz
• Alle 2–24 Stunden — für Sticky Sessions (permanente Sitzung)

✅ Vorteile:

• Vorhersehbarkeit — Sie wissen genau, wann der IP-Wechsel stattfindet
• Einfache Implementierung — leicht mit Timern einzurichten
• Geeignet für Sticky Sessions — kann die Sitzung für eine bestimmte Zeit beibehalten
• Gleichmäßige Verteilung — die Last verteilt sich zeitlich gleichmäßig
• Leicht skalierbar — mehrere Sitzungen mit unterschiedlichen Timern können parallel ausgeführt werden

❌ Nachteile:

• Ineffektiv bei variabler Last — die IP wechselt unnötigerweise, wenn wenig Anfragen gesendet werden
• Risiko der Überschreitung von Limits — wenn zu viele Anfragen in kurzer Zeit gesendet werden
• Vorhersehbares Muster — fortgeschrittene Schutzsysteme können die Regelmäßigkeit erkennen
• Sitzungsverlust — bei IP-Wechsel kann die Autorisierung oder der Kontext verloren gehen

🎯 Am besten geeignet für:

• Aufgaben mit vorhersehbarer Last
• Langfristige Sitzungen (Autorisierung, Kontoverwaltung)
• Überwachung mit festen Intervallen
• Situationen, in denen eine stabile IP für eine bestimmte Zeit wichtig ist

10:00 - Proxy A → Preisprüfung (50 Produkte)
10:30 - Proxy B → Preisprüfung (50 Produkte)
11:00 - Proxy C → Preisprüfung (50 Produkte)
11:30 - Proxy D → Preisprüfung (50 Produkte)
12:00 - Proxy A → Preisprüfung (50 Produkte)

Implementierungsoptionen:

1. Per-request rotation — neue IP für jede Anfrage (aggressivste Strategie)
2. Burst rotation — Wechsel der IP nach N Anfragen (z. B. alle 10 Anfragen)
3. Adaptive rotation — Wechsel der IP bei Erhalt bestimmter HTTP-Codes (429, 403, 503)
4. Session-based — Wechsel der IP beim Start einer neuen logischen Sitzung

✅ Vorteile:

• Maximaler Schutz vor Rate Limiting — jede IP stellt minimal Anfragen
• Adaptivität — Rotation erfolgt nur bei Bedarf
• Effiziente Nutzung des Pools — IPs wechseln nur, wenn nötig
• Schnelle Reaktion auf Sperrungen — sofortiger IP-Wechsel bei Fehlern möglich
• Ideal für Scraping — jede Seite wird mit einer neuen IP angefragt

❌ Nachteile:

• Keine Speicherung der Sitzung möglich — ständiger IP-Wechsel unterbricht die Autorisierung
• Schwierigere Fehlerbehebung — Probleme mit einer bestimmten IP sind schwer zu reproduzieren
• Schnelle Erschöpfung des Pools — bei intensiver Arbeit können alle IPs schnell verbraucht werden
• Teurer — erfordert einen größeren Proxy-Pool für effizientes Arbeiten
• Overhead beim Wechsel — jeder IP-Wechsel kostet Bruchteile von Sekunden

🎯 Am besten geeignet für:

• Intensives Scraping großer Datenmengen
• Umgehung strenger Rate Limits
• Einmalige Anfragen ohne Notwendigkeit der Zustandsspeicherung
• Scraping öffentlicher Seiten ohne Autorisierung
• Aufgaben, bei denen jede Anfrage unabhängig von der vorherigen ist

Art der Website	Empfohlene Anzahl Anfragen	Intervall
Hochsicher (Banken, soziale Netzwerke)	1–3 Anfragen	5–10 Sek. zwischen Anfragen
E-Commerce (Marktplätze)	5–10 Anfragen	2–5 Sek. zwischen Anfragen
Nachrichtenportale	10–20 Anfragen	1–3 Sek. zwischen Anfragen
Öffentliche APIs	Abhängig von Limits	Gemäß Dokumentation
Statische Websites	20–50 Anfragen	0,5–2 Sek. zwischen Anfragen

Varianten der zufälligen Rotation:

• Zufällige Zeitintervalle — Wechsel der IP nach zufälligen Abständen (z. B. zwischen 3 und 15 Minuten)
• Zufällige Anzahl von Anfragen — Wechsel nach einer zufälligen Anzahl von Anfragen (z. B. zwischen 5 und 20)
• Zufällige IP-Auswahl — die Auswahl der nächsten IP aus dem Pool erfolgt zufällig und nicht sequenziell
• Gewichtete Zufälligkeit — IPs mit besserer Reputation werden häufiger verwendet
• Jittered Rotation — Hinzufügen einer zufälligen Verzögerung zu festen Intervallen

✅ Vorteile:

• Unvorhersehbarkeit — Schutzsystemen fällt es schwerer, ein Muster zu erkennen
• Imitation realer Benutzer — Menschen handeln nicht mit perfekter Regelmäßigkeit
• Flexibilität — kann mit anderen Strategien kombiniert werden
• Natürliches Traffic-Muster — ähnelt organischem Traffic
• Schwerer zu erkennen — selbst bei der Analyse großer Datenmengen

❌ Nachteile:

• Schwerer zu prognostizieren — die Geschwindigkeit der Aufgabe ist schwer abzuschätzen
• Kann ineffizient sein — bei unglücklicher Zufälligkeit kann die IP zu oft wechseln
• Erschwerte Fehlerbehebung — die Reproduktion eines Problems ist aufgrund der Zufälligkeit schwieriger
• Erfordert einen größeren Pool — um eine gleichmäßige Auslastung zu gewährleisten
• Komplexere Implementierung — erfordert einen guten Algorithmus zur Zufallsgenerierung

🎯 Am besten geeignet für:

• Umgehung fortschrittlicher Schutzsysteme (Cloudflare, Akamai)
• Langfristige Projekte mit hohen Anforderungen an Unauffälligkeit
• Wettbewerbsanalyse
• Scraping von Websites mit Verhaltensanalyse
• Aufgaben, bei denen maximale Imitation menschlichen Verhaltens erforderlich ist

Kriterium	Zeitbasiert	Anfragebasiert	Zufällig
Implementierungskomplexität	⭐ Einfach	⭐⭐ Mittel	⭐⭐⭐ Komplex
Vorhersehbarkeit	✅ Hoch	⚠️ Mittel	❌ Niedrig
Schutz vor Rate Limit	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Unauffälligkeit	⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐
Sitzungsunterstützung	✅ Ja	❌ Nein	⚠️ Teilweise
Effizienz der Pool-Nutzung	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Scraping-Geschwindigkeit	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Erforderliche Pool-Größe	Klein-Mittel	Groß	Mittel-Groß
Einfache Fehlerbehebung	✅ Einfach	⚠️ Mittel	❌ Schwer
Kosten	💰 Niedrig	💰💰💰 Hoch	💰💰 Mittel

Typische Einstellungen für Sticky Sessions:

• 1–5 Minuten — kurze Sitzungen für schnelle Operationen
• 10–30 Minuten — Standardmodus für die meisten Aufgaben
• 1–2 Stunden — für die Arbeit mit Konten und Autorisierung
• 12–24 Stunden — maximale Dauer für langfristige Operationen
• Unendlich (bis zur Trennung) — IP bleibt bis zum Ende der Sitzung erhalten

✅ Vorteile von Sticky Sessions:

• Speicherung der Autorisierung — man kann sich anmelden und im Namen des Kontos arbeiten
• Unterstützung von Cookies — die Website "erinnert" sich an Sie zwischen Anfragen
• Natürliches Verhalten — ein normaler Benutzer verwendet während einer Sitzung dieselbe IP
• Weniger CAPTCHAs — eine konstante IP erregt weniger Verdacht
• Sequenzielle Aktionen — kann Multi-Step-Operationen durchführen
• Einfachere Fehlerbehebung — Probleme mit einer bestimmten IP sind leichter zu reproduzieren

❌ Nachteile von Sticky Sessions:

• Anfälligkeit für Rate Limiting — alle Anfragen kommen von derselben IP
• Risiko des gesamten Sitzungsbanns — wenn die IP gesperrt wird, verlieren Sie den gesamten Fortschritt
• Geringere Skalierbarkeit — begrenzt durch die Geschwindigkeit einer einzelnen IP
• Endliche Dauer — die Sitzung läuft unweigerlich ab und die IP wechselt

✅ Vorteile von Rotating Proxies:

• Maximaler Schutz vor Rate Limiting — jede IP stellt minimale Anfragen
• Hohe Scraping-Geschwindigkeit — Tausende parallele Anfragen möglich
• Minimales Sperrrisiko — selbst wenn eine IP gesperrt wird, wirkt sich dies nicht auf die Arbeit aus
• Skalierbarkeit — das Arbeitsvolumen lässt sich leicht erhöhen
• Unauffälligkeit — sieht aus wie viele unabhängige Benutzer

❌ Nachteile von Rotating Proxies:

• Keine Autorisierung möglich — ständiger IP-Wechsel zerstört die Sitzung
• Cookies funktionieren nicht — jede Anfrage sieht aus wie von einem neuen Benutzer
• Keine Multi-Step-Operationen möglich — Warenkorb, Formulare, Checkout funktionieren nicht
• Mehr CAPTCHAs — häufiger IP-Wechsel kann Verdacht erregen
• Teurer — erfordert einen großen Proxy-Pool

Kriterium	Sticky Sessions	Rotating Proxies
Autorisierung	✅ Ja	❌ Nein
Cookies	✅ Funktionieren	❌ Funktionieren nicht
Rate Limit Umgehung	⚠️ Begrenzt	✅ Exzellent
Scraping-Geschwindigkeit	⭐⭐⭐	⭐⭐⭐⭐⭐
Sperrrisiko	⚠️ Mittel	✅ Niedrig
Kosten	💰 Niedriger	💰💰 Höher
Komplexität	⭐ Einfach	⭐⭐ Mittel

1. Verwaltung sozialer Netzwerke

Bei der Arbeit mit mehreren Instagram-, Facebook- oder Twitter-Konten muss dieselbe IP während der gesamten Sitzung beibehalten werden. Ein häufiger IP-Wechsel bei einem angemeldeten Konto führt direkt zur Sperrung.

Empfehlung: Sticky Session 1–2 Stunden, eine eindeutige IP pro Konto.

2. E-Commerce und Warenkörbe

Hinzufügen von Artikeln zum Warenkorb, Bestellabwicklung, Checkout-Prozess – all dies erfordert die Beibehaltung der Sitzung. Ein IP-Wechsel führt zum Verlust des Warenkorbs und erfordert einen Neustart.

Empfehlung: Sticky Session 30–60 Minuten für den gesamten Kaufvorgang.

3. Ausfüllen von Formularen und Registrierung

Multi-Step-Formulare, Website-Registrierungen, E-Mail-Verifizierung – all diese Prozesse erfordern eine konstante IP. Ein Wechsel zwischen den Schritten kann Verdacht erregen oder zu Validierungsfehlern führen.

Empfehlung: Sticky Session 10–30 Minuten, um den Vorgang abzuschließen.

4. Testen von Webanwendungen

End-to-End-Tests, Automatisierung mit Selenium/Puppeteer, Überprüfung von Benutzerszenarien – all dies erfordert die Beibehaltung der IP, um die Erfahrung eines realen Benutzers zu simulieren.

Empfehlung: Sticky Session für die gesamte Dauer des Tests (5–60 Minuten).

5. Arbeit mit authentifizierungspflichtigen APIs

Viele APIs geben ein Zugriffstoken aus, das an die IP-Adresse gebunden ist. Ein IP-Wechsel führt zur Invalidierung des Tokens und erfordert eine erneute Authentifizierung.

Empfehlung: Sticky Session für die Lebensdauer des Tokens (normalerweise 1–24 Stunden).

import requests
from itertools import cycle

# Liste der Proxys
proxies_list = [
    'http://user:pass@185.45.12.34:8000',
    'http://user:pass@92.118.45.78:8000',
    'http://user:pass@178.62.91.22:8000',
    'http://user:pass@45.89.234.56:8000'
]

# Erstellen eines unendlichen Iterators
proxy_pool = cycle(proxies_list)

# Funktion zum Senden einer Anfrage
def make_request(url):
    proxy = next(proxy_pool)
    proxies = {
        'http': proxy,
        'https': proxy
    }

    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"Erfolg mit {proxy}: {response.status_code}")
        return response
    except Exception as e:
        print(f"Fehler mit {proxy}: {e}")
        return None

# Verwendung
urls = ['https://example.com/page1', 'https://example.com/page2']
for url in urls:
    make_request(url)
    # Jede Anfrage verwendet den nächsten Proxy aus der Liste

import requests
import random
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ProxyRotator:
    def __init__(self, proxies_list):
        self.proxies = proxies_list
        self.failed_proxies = set()

    def get_random_proxy(self):
        """Zufälligen funktionierenden Proxy erhalten"""
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            # Wenn alle Proxys fehlgeschlagen sind, setzen wir die Liste zurück
            self.failed_proxies.clear()
            available = self.proxies
        return random.choice(available)

    def make_request(self, url, max_retries=3):
        """Senden der Anfrage mit automatischer Rotation bei Fehlern"""
        session = requests.Session()

        # Konfiguration der Retry-Strategie
        retry = Retry(
            total=max_retries,
            backoff_factor=0.5,
            status_forcelist=[500, 502, 503, 504]
        )
        adapter = HTTPAdapter(max_retries=retry)
        session.mount('http://', adapter)
        session.mount('https://', adapter)

        for attempt in range(max_retries):
            proxy = self.get_random_proxy()
            proxies = {'http': proxy, 'https': proxy}

            try:
                response = session.get(url, proxies=proxies, timeout=15)

                # Prüfung auf Rate Limiting
                if response.status_code == 429:
                    print(f"Rate limited auf {proxy}, rotiere...")
                    self.failed_proxies.add(proxy)
                    continue

                print(f"✓ Erfolg mit {proxy}")
                return response

            except Exception as e:
                print(f"✗ Fehler mit {proxy}: {e}")
                self.failed_proxies.add(proxy)

        raise Exception(f"Alle Wiederholungsversuche für {url} fehlgeschlagen")

# Verwendung
proxies = [
    'http://user:pass@proxy1.com:8000',
    'http://user:pass@proxy2.com:8000',
    'http://user:pass@proxy3.com:8000'
]

rotator = ProxyRotator(proxies)
response = rotator.make_request('https://example.com')

import requests
import time
from datetime import datetime, timedelta

class TimeBasedRotator:
    def __init__(self, proxies_list, rotation_interval=600):
        """
        rotation_interval: Zeit in Sekunden (600 = 10 Minuten)
        """
        self.proxies = proxies_list
        self.rotation_interval = rotation_interval
        self.current_proxy = None
        self.last_rotation = None
        self.current_index = 0

    def get_proxy(self):
        """Aktuellen Proxy erhalten oder rotieren, wenn die Zeit abgelaufen ist"""
        now = datetime.now()

        # Erster Start oder Zeit abgelaufen
        if (self.last_rotation is None or
            (now - self.last_rotation).seconds >= self.rotation_interval):

            self.current_proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            self.last_rotation = now
            print(f"🔄 Rotiert zu: {self.current_proxy}")

        return self.current_proxy

    def make_request(self, url):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}

        response = requests.get(url, proxies=proxies, timeout=10)
        return response

# Verwendung: IP wechselt alle 10 Minuten
rotator = TimeBasedRotator(proxies_list, rotation_interval=600)

for i in range(100):
    response = rotator.make_request('https://example.com')
    print(f"Anfrage {i}: {response.status_code}")
    time.sleep(2)  # 2 Sekunden zwischen den Anfragen

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async makeRequest(url, options = {}) {
    const proxy = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxy);

    try {
      const response = await axios.get(url, {
        ...options,
        httpAgent: agent,
        httpsAgent: agent,
        timeout: 10000
      });

      console.log(`✓ Erfolg mit ${proxy}: ${response.status}`);
      return response.data;

    } catch (error) {
      console.error(`✗ Fehler mit ${proxy}: ${error.message}`);
      throw error;
    }
  }
}

// Verwendung
const proxies = [
  'http://user:pass@proxy1.com:8000',
  'http://user:pass@proxy2.com:8000',
  'http://user:pass@proxy3.com:8000'
];

const rotator = new ProxyRotator(proxies);

async function scrape() {
  const urls = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3'
  ];

  for (const url of urls) {
    try {
      await rotator.makeRequest(url);
    } catch (error) {
      console.error(`Fehler beim Scraping von ${url}`);
    }
  }
}

scrape();

const puppeteer = require('puppeteer');

class PuppeteerProxyRotator {
  constructor(proxies) {
    this.proxies = proxies;
    this.currentIndex = 0;
  }

  getNextProxy() {
    const proxy = this.proxies[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxies.length;
    return proxy;
  }

  async scrapeWithRotation(url) {
    const proxy = this.getNextProxy();

    // Parsing der Proxy-URL
    const proxyUrl = new URL(proxy);

    const browser = await puppeteer.launch({
      headless: true,
      args: [
        `--proxy-server=${proxyUrl.protocol}//${proxyUrl.host}`,
        '--no-sandbox',
        '--disable-setuid-sandbox'
      ]
    });

    try {
      const page = await browser.newPage();

      // Proxy-Authentifizierung, falls vorhanden
      if (proxyUrl.username && proxyUrl.password) {
        await page.authenticate({
          username: proxyUrl.username,
          password: proxyUrl.password
        });
      }

      await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

      const content = await page.content();
      console.log(`✓ Gescraped ${url} mit ${proxy}`);

      await browser.close();
      return content;

    } catch (error) {
      console.error(`✗ Fehler mit ${proxy}: ${error.message}`);
      await browser.close();
      throw error;
    }
  }
}

// Verwendung
const proxies = [
  'http://user:pass@185.45.12.34:8000',
  'http://user:pass@92.118.45.78:8000'
];

const rotator = new PuppeteerProxyRotator(proxies);

async function scrapeMultiplePages() {
  const urls = ['https://example.com/1', 'https://example.com/2'];

  for (const url of urls) {
    await rotator.scrapeWithRotation(url);
    // Jede Seite wird mit einem neuen Proxy geöffnet
  }
}

scrapeMultiplePages();

Funktionsweise:

1. Sie verbinden sich mit einem einzigen Endpunkt (z. B. rotate.proxycove.com:8000)
2. Bei jeder Anfrage wählt das Gateway automatisch eine zufällige IP aus dem Pool aus
3. Sie müssen die Proxy-Liste nicht verwalten und keine Rotationslogik programmieren
4. Sticky Sessions können über Parameter konfiguriert werden (session_id im Benutzernamen)

# Python Beispiel mit Rotating Gateway
import requests

# Für Rotating: Jede Anfrage = neue IP
proxies = {
    'http': 'http://username:password@rotate.proxycove.com:8000',
    'https': 'http://username:password@rotate.proxycove.com:8000'
}

# Für Sticky Session: session_id zum Benutzernamen hinzufügen
sticky_proxies = {
    'http': 'http://username-session-abc123:password@rotate.proxycove.com:8000',
    'https': 'http://username-session-abc123:password@rotate.proxycove.com:8000'
}

# Rotating: Jede Anfrage mit neuer IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=proxies)
    print(f"Anfrage {i}: IP = {r.text}")  # Jedes Mal eine andere IP

# Sticky: Alle Anfragen mit derselben IP
for i in range(10):
    r = requests.get('https://api.ipify.org', proxies=sticky_proxies)
    print(f"Anfrage {i}: IP = {r.text}")  # Immer dieselbe IP

1. ProxyBroker

Bibliothek zum Finden, Überprüfen und Verwenden von Proxys mit automatischer Rotation.

2. rotating-proxies (Scrapy Middleware)

Middleware für Scrapy mit Unterstützung für automatische Rotation und Blacklist-Verwaltung.

3. requests-ip-rotator

Erweiterung für die requests-Bibliothek mit Unterstützung für AWS API Gateway zur IP-Rotation.

1. proxy-chain

Bibliothek zum Erstellen eines HTTP-Proxy-Servers mit Rotation und Tunneling.

2. puppeteer-extra-plugin-proxy-rotation

Plugin für Puppeteer mit automatischer Proxy-Rotation für jede Seite.