Was tun, wenn Proxys ständig gesperrt werden: Vollständiger Leitfaden zur Diagnose und Problemlösung

Ständige Proxy-Blockierungen sind eines der häufigsten Probleme beim Web-Scraping, bei der Automatisierung und bei der Arbeit mit mehreren Konten. In diesem Artikel werden wir analysieren, warum dies geschieht und wie man das Problem systematisch löst, anstatt endlos die Anbieter zu wechseln in der Hoffnung auf ein Wunder.

Warum Proxys wirklich gesperrt werden

Bevor Sie nach einer Lösung suchen, müssen Sie die Mechanik der Blockierungen verstehen. Moderne Anti-Fraud-Systeme verwenden mehrschichtigen Schutz, und die Proxy-Sperrung ist nur eine Folge, nicht die Ursache. Das Verständnis, wie diese Systeme funktionieren, ermöglicht es Ihnen, eine effektive Umgehungsstrategie zu entwickeln.

IP-Reputation und schwarze Listen

Jede IP-Adresse hat einen Ruf, der auf der Grundlage ihrer Nutzungsgeschichte aufgebaut wird. Wenn eine Adresse zuvor für Spam, DDoS-Angriffe oder Massen-Scraping verwendet wurde, wird sie in Datenbanken wie Spamhaus, SORBS oder proprietäre Listen bestimmter Dienste aufgenommen. Wenn Sie sich über eine solche IP verbinden, behandelt das System Sie sofort mit Verdacht.

Rechenzentrum-Proxys sind besonders anfällig für dieses Problem. Ganze IP-Subnetze können als "Hosting" gekennzeichnet werden, und jeder Datenverkehr von ihnen erhält automatisch ein erhöhtes Überprüfungsniveau. Amazon AWS, Google Cloud, DigitalOcean – ihre IP-Bereiche sind gut bekannt und werden oft präventiv blockiert.

Sie können die IP-Reputation über Dienste wie IPQualityScore, Scamalytics oder AbuseIPDB überprüfen. Wenn Ihr Proxy einen Fraud-Score über 75 anzeigt, liegt das Problem genau hier – wechseln Sie den Anbieter oder den Proxy-Typ.

Anfragemuster

Ein Mensch macht nicht 100 Anfragen pro Sekunde. Ein Mensch wechselt nicht mit perfekter Regelmäßigkeit alle 2 Sekunden zwischen Seiten. Ein Mensch ignoriert nicht Bilder, CSS und JavaScript und fordert nur HTML an. Anti-Fraud-Systeme analysieren genau diese Muster, und jede Abweichung vom "menschlichen" Verhalten erhöht das Blockierungsrisiko.

Besonders aussagekräftig ist die Statistik der Zeit zwischen Anfragen. Wenn Sie einen stabilen Intervall haben – das ist ein klares Zeichen für Automatisierung. Das Hinzufügen einer zufälligen Verzögerung (z. B. 1 bis 5 Sekunden) reduziert die Erkennungswahrscheinlichkeit erheblich.

Metadaten-Nichtübereinstimmung

Wenn Ihr User-Agent sagt, dass Sie Chrome unter Windows verwenden, aber HTTP-Header die Eigenschaften von Python-Anfragen verraten – das ist ein rotes Flagge. Wenn die IP-Adresse in Deutschland geolokalisiert ist, aber die Spracheinstellungen des Browsers auf Russisch eingestellt sind – noch ein rotes Flagge. Wenn die Zeitzone in JavaScript nicht mit der Geografie der IP übereinstimmt – das dritte Flagge.

Die Ansammlung solcher Unstimmigkeiten führt dazu, dass das System die Verbindung als verdächtig einstuft und Schutzmaßnahmen ergreift: von Captchas bis zur vollständigen IP-Blockierung.

Browser-Fingerprint

Moderne Schutzsysteme sammeln Dutzende von Browser-Parametern: Bildschirmauflösung, installierte Schriftarten, Plugins, WebGL-Rendering, Audio-Kontext und vieles mehr. Die Kombination dieser Parameter erzeugt einen eindeutigen "Abdruck", der auch bei IP-Wechsel konstant bleibt.

Wenn Sie den Proxy wechseln, aber der Fingerprint gleich bleibt, versteht das System, dass Sie derselbe Benutzer sind. Und wenn ein Fingerprint in kurzer Zeit von Hunderten verschiedener IPs auftaucht – das ist ein klares Zeichen für Automatisierung.

Diagnose: Wie man die Blockierungsursache versteht

Bevor Sie blind Einstellungen ändern, führen Sie eine Diagnose durch. Dies spart Stunden von Experimenten und hilft, die eigentliche Ursache des Problems zu finden. Ein systematischer Diagnoseansatz ist der Schlüssel zu einer effektiven Lösung.

Schritt 1: Überprüfen Sie den Proxy selbst

Beginnen Sie mit einer grundlegenden Funktionsprüfung des Proxys unabhängig von Ihrem Hauptskript:

import requests

proxy = {
    "http": "http://user:pass@proxy-server:port",
    "https": "http://user:pass@proxy-server:port"
}

# Überprüfung der grundlegenden Funktionalität
try:
    response = requests.get("https://httpbin.org/ip", proxies=proxy, timeout=10)
    print(f"IP über Proxy: {response.json()['origin']}")
except Exception as e:
    print(f"Verbindungsfehler: {e}")

# Überprüfung auf echte IP-Lecks
response = requests.get("https://browserleaks.com/ip", proxies=proxy)
# Vergleichen Sie mit Ihrer echten IP

Wenn der Proxy nicht einmal bei einfachen Anfragen funktioniert – liegt das Problem im Proxy selbst oder in den Anmeldedaten. Überprüfen Sie das Verbindungsformat, das Guthaben auf dem Konto und die Anbieter-Limits.

Schritt 2: Überprüfen Sie die IP-Reputation

Verwenden Sie mehrere Dienste für eine umfassende Bewertung:

# Holen Sie sich die Proxy-IP
proxy_ip = requests.get("https://api.ipify.org", proxies=proxy).text

# Überprüfen Sie auf diesen Diensten:
# https://www.ipqualityscore.com/free-ip-lookup-proxy-vpn-test
# https://scamalytics.com/ip/{proxy_ip}
# https://www.abuseipdb.com/check/{proxy_ip}
# https://whatismyipaddress.com/ip/{proxy_ip}

print(f"Überprüfen Sie IP {proxy_ip} auf den oben genannten Diensten")

Achten Sie auf die folgenden Indikatoren: Fraud-Score (sollte unter 50 liegen), IP-Typ (Residential ist besser als Datacenter), Vorhandensein in schwarzen Listen. Wenn die IP als VPN/Proxy gekennzeichnet ist – werden viele Websites sie von Anfang an verdächtig behandeln.

Schritt 3: Isolieren Sie das Problem

Versuchen Sie denselben Proxy auf verschiedenen Zielwebsites. Wenn die Blockierung überall auftritt – liegt das Problem im Proxy oder Ihrer Konfiguration. Wenn nur auf einer bestimmten Website – liegt das Problem in der Schutzmaßnahme dieser Website oder Ihrem Verhalten darauf.

Versuchen Sie auch verschiedene Proxys auf einer Website. Wenn alle blockiert werden – liegt das Problem nicht im Proxy, sondern in Ihrem Skript, Fingerprint oder Verhaltensmuster. Dies ist ein kritisch wichtiger Test, den viele überspringen.

Schritt 4: Analyse der Serverantworten

Verschiedene Blockierungstypen manifestieren sich unterschiedlich. Lernen Sie, sie zu unterscheiden:

def analyze_response(response):
    status = response.status_code
    
    if status == 403:
        print("Zugriff verweigert – möglicherweise IP in schwarzer Liste")
    elif status == 429:
        print("Zu viele Anfragen – reduzieren Sie die Häufigkeit")
    elif status == 503:
        print("Dienst nicht verfügbar – möglicherweise DDoS-Schutz")
    elif status == 407:
        print("Proxy-Authentifizierung erforderlich – überprüfen Sie die Anmeldedaten")
    elif "captcha" in response.text.lower():
        print("Captcha erkannt – Botverdacht")
    elif "blocked" in response.text.lower():
        print("Explizite Blockierung – wechseln Sie die IP und überdenken Sie den Ansatz")
    elif len(response.text) < 1000:
        print("Verdächtig kurze Antwort – möglicherweise ein Stub")
    else:
        print(f"Status {status}, Antwortlänge: {len(response.text)}")

Korrekte Rotation: Häufigkeit, Logik, Implementierung

Proxy-Rotation ist nicht einfach "IP öfter wechseln". Falsche Rotation kann mehr schaden als nutzen. Lassen Sie uns verschiedene Strategien und deren Anwendungsfälle betrachten.

Strategie 1: Rotation nach Anfragezahl

Der einfachste Ansatz – wechseln Sie die IP nach einer bestimmten Anzahl von Anfragen. Geeignet für Web-Scraping, wo Sitzungspersistenz nicht erforderlich ist:

import random

class ProxyRotator:
    def __init__(self, proxy_list, requests_per_proxy=50):
        self.proxies = proxy_list
        self.requests_per_proxy = requests_per_proxy
        self.current_proxy = None
        self.request_count = 0
    
    def get_proxy(self):
        if self.current_proxy is None or self.request_count >= self.requests_per_proxy:
            # Fügen Sie Zufälligkeit in die Anfragezahl ein
            self.requests_per_proxy = random.randint(30, 70)
            self.current_proxy = random.choice(self.proxies)
            self.request_count = 0
        
        self.request_count += 1
        return self.current_proxy

# Verwendung
rotator = ProxyRotator(proxy_list)
for url in urls_to_scrape:
    proxy = rotator.get_proxy()
    response = requests.get(url, proxies={"http": proxy, "https": proxy})

Beachten Sie die Zufälligkeit in der Anfragezahl pro Proxy. Eine feste Zahl (z. B. genau 50) ist ein Muster, das erkannt werden kann. Ein zufälliger Bereich macht das Verhalten weniger vorhersehbar.

Strategie 2: Zeitbasierte Rotation

Für Aufgaben, bei denen Sitzungspersistenz wichtig ist (z. B. Kontoverwaltung), ist es besser, die IP an die Zeit zu binden:

import time
import random

class TimeBasedRotator:
    def __init__(self, proxy_list, min_minutes=10, max_minutes=30):
        self.proxies = proxy_list
        self.min_seconds = min_minutes * 60
        self.max_seconds = max_minutes * 60
        self.current_proxy = None
        self.rotation_time = 0
    
    def get_proxy(self):
        current_time = time.time()
        
        if self.current_proxy is None or current_time >= self.rotation_time:
            self.current_proxy = random.choice(self.proxies)
            # Zufälliges Intervall bis zur nächsten Rotation
            interval = random.randint(self.min_seconds, self.max_seconds)
            self.rotation_time = current_time + interval
            print(f"Neuer Proxy, nächste Rotation in {interval//60} Minuten")
        
        return self.current_proxy

Strategie 3: Sticky Sessions für Konten

Bei der Arbeit mit mehreren Konten ist es kritisch, dass jedes Konto eine konstante IP verwendet. Ein IP-Wechsel für ein angemeldetes Konto ist ein sicherer Weg zur Sperrung:

class AccountProxyManager:
    def __init__(self, proxy_pool):
        self.proxy_pool = proxy_pool
        self.account_proxies = {}  # account_id -> proxy
        self.used_proxies = set()
    
    def get_proxy_for_account(self, account_id):
        # Wenn dem Konto bereits ein Proxy zugewiesen ist – geben Sie ihn zurück
        if account_id in self.account_proxies:
            return self.account_proxies[account_id]
        
        # Finden Sie einen freien Proxy
        available = [p for p in self.proxy_pool if p not in self.used_proxies]
        
        if not available:
            raise Exception("Keine freien Proxys für neue Konten")
        
        proxy = random.choice(available)
        self.account_proxies[account_id] = proxy
        self.used_proxies.add(proxy)
        
        return proxy
    
    def release_account(self, account_id):
        """Gibt den Proxy frei, wenn das Konto gelöscht wird"""
        if account_id in self.account_proxies:
            proxy = self.account_proxies.pop(account_id)
            self.used_proxies.discard(proxy)

# Verwendung
manager = AccountProxyManager(residential_proxy_list)

for account in accounts:
    proxy = manager.get_proxy_for_account(account.id)
    # Alle Aktionen dieses Kontos gehen über eine IP

Strategie 4: Adaptive Rotation

Der fortgeschrittenste Ansatz – wechseln Sie den Proxy als Reaktion auf Signale von der Zielwebsite:

class AdaptiveRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_proxy = random.choice(proxy_list)
        self.proxy_scores = {p: 100 for p in proxy_list}  # Anfängliche Proxy-"Gesundheit"
    
    def get_proxy(self):
        return self.current_proxy
    
    def report_result(self, success, response_code=200):
        """Wird nach jeder Anfrage aufgerufen"""
        if success and response_code == 200:
            # Erfolgreiche Anfrage – erhöhen Sie den Score leicht
            self.proxy_scores[self.current_proxy] = min(100, 
                self.proxy_scores[self.current_proxy] + 1)
        elif response_code == 429:
            # Rate Limit – Score stark senken und rotieren
            self.proxy_scores[self.current_proxy] -= 30
            self._rotate()
        elif response_code == 403:
            # Sperrung – Score auf Null setzen und rotieren
            self.proxy_scores[self.current_proxy] = 0
            self._rotate()
        elif response_code == 503:
            # Möglicher Schutz – Score senken und rotieren
            self.proxy_scores[self.current_proxy] -= 20
            self._rotate()
    
    def _rotate(self):
        # Wählen Sie den Proxy mit dem besten Score
        available = [(p, s) for p, s in self.proxy_scores.items() if s > 20]
        if not available:
            # Alle Proxys sind "tot" – Scores zurücksetzen
            self.proxy_scores = {p: 50 for p in self.proxies}
            available = list(self.proxy_scores.items())
        
        # Gewichtete Auswahl nach Score
        self.current_proxy = max(available, key=lambda x: x[1])[0]
        print(f"Rotation zu Proxy mit Score {self.proxy_scores[self.current_proxy]}")

Browser-Fingerprint und seine Rolle bei Blockierungen

Fingerprint ist die Gesamtheit der Browser-Eigenschaften, die es ermöglichen, einen Benutzer auch ohne Cookies zu identifizieren. Wenn Sie den Proxy wechseln, aber der Fingerprint gleich bleibt, verbindet das Schutzsystem leicht alle Ihre Sitzungen miteinander.

Woraus besteht der Fingerprint

Der moderne Fingerprint umfasst Dutzende von Parametern. Hier sind die Hauptkategorien:

Konsistenz von Fingerprint und IP

Es ist kritisch wichtig, dass der Fingerprint der Geografie der IP entspricht. Wenn der Proxy in Deutschland ist, sollte der Fingerprint wie ein deutscher Benutzer aussehen:

// Beispiel für Nichtübereinstimmung (SCHLECHT):
// IP: Deutschland
// Zeitzone: America/New_York
// Sprachen: ["ru-RU", "ru"]
// Dies wird Verdacht erregen

// Konsistenter Fingerprint (GUT):
// IP: Deutschland
// Zeitzone: Europe/Berlin
// Sprachen: ["de-DE", "de", "en-US", "en"]

Tools zur Fingerprint-Verwaltung

Verwenden Sie für ernsthafte Arbeit spezialisierte Tools:

Playwright mit Stealth:

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={"server": "http://proxy:port", "username": "user", "password": "pass"}
    )
    
    context = browser.new_context(
        viewport={"width": 1920, "height": 1080},
        locale="de-DE",
        timezone_id="Europe/Berlin",
        geolocation={"latitude": 52.52, "longitude": 13.405},
        permissions=["geolocation"]
    )
    
    page = context.new_page()
    stealth_sync(page)  # Wenden Sie Stealth-Patches an
    
    page.goto("https://target-site.com")

Puppeteer mit puppeteer-extra:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    args: [`--proxy-server=http://proxy:port`]
});

const page = await browser.newPage();

// Überschreiben Sie die Zeitzone
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(Intl.DateTimeFormat.prototype, 'resolvedOptions', {
        value: function() {
            return { timeZone: 'Europe/Berlin' };
        }
    });
});

Anti-Detect-Browser

Für die Kontoverwaltung werden häufig Anti-Detect-Browser verwendet (Multilogin, GoLogin, Dolphin Anty und andere). Sie ermöglichen die Erstellung isolierter Profile mit eindeutigen Fingerprints. Jedes Profil hat seinen eigenen Satz von Parametern, Cookies, localStorage – eine vollständig isolierte Umgebung.

Der Vorteil von Anti-Detect-Browsern ist, dass sie das Fingerprint-Problem "out of the box" lösen. Der Nachteil ist der Preis und die Komplexität der Automatisierung (obwohl viele eine API haben).

Verhaltensmuster: Wie man nicht wie ein Bot aussieht

Auch mit perfektem Fingerprint und sauberer IP können Sie wegen unmenschlichen Verhaltens gesperrt werden. Moderne Systeme analysieren nicht nur technische Parameter, sondern auch Interaktionsmuster mit der Website.

Zeitliche Verzögerungen

Ein Mensch macht keine Anfragen mit konstanten Intervallen. Fügen Sie zufällige Verzögerungen mit Normalverteilung hinzu:

import random
import time
import numpy as np

def human_delay(min_sec=1, max_sec=5, mean=2.5):
    """
    Generiert eine menschenähnliche Verzögerung.
    Verwendet eine logarithmische Normalverteilung – 
    die meisten Verzögerungen sind kurz, aber manchmal gibt es lange.
    """
    delay = np.random.lognormal(mean=np.log(mean), sigma=0.5)
    delay = max(min_sec, min(max_sec, delay))
    return delay

def human_typing_delay():
    """Verzögerung zwischen Tastendrücken beim Tippen"""
    return random.uniform(0.05, 0.25)

# Verwendung
for url in urls:
    response = requests.get(url, proxies=proxy)
    process(response)
    time.sleep(human_delay())  # Zufällige Pause zwischen Anfragen

Imitation der Navigation

Ein Mensch geht nicht direkt über einen direkten Link zur Produktseite. Er geht zur Startseite, nutzt die Suche, durchsucht Kategorien. Imitieren Sie diesen Weg:

async def human_like_navigation(page, target_url):
    """Imitiert menschenähnliche Navigation zur Zielseite"""
    
    # 1. Gehen Sie zur Startseite
    await page.goto("https://example.com")
    await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 2. Manchmal scrollen Sie die Startseite
    if random.random() > 0.5:
        await page.evaluate("window.scrollBy(0, 300)")
        await page.wait_for_timeout(random.randint(1000, 2000))
    
    # 3. Verwenden Sie Suche oder Navigation
    if random.random() > 0.3:
        search_box = await page.query_selector('input[type="search"]')
        if search_box:
            await search_box.type("search query", delay=100)
            await page.keyboard.press("Enter")
            await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 4. Gehen Sie zur Zielseite
    await page.goto(target_url)
    
    # 5. Scrollen Sie die Seite wie ein Mensch
    await human_scroll(page)

async def human_scroll(page):
    """Imitiert menschliches Scrollen"""
    scroll_height = await page.evaluate("document.body.scrollHeight")
    current_position = 0
    
    while current_position < scroll_height * 0.7:  # Nicht bis zum Ende
        scroll_amount = random.randint(200, 500)
        await page.evaluate(f"window.scrollBy(0, {scroll_amount})")
        current_position += scroll_amount
        await page.wait_for_timeout(random.randint(500, 1500))

Mausbewegungen

Einige Systeme verfolgen Mausbewegungen. Eine geradlinige Bewegung von Punkt A zu Punkt B ist ein Zeichen eines Bots. Ein Mensch bewegt die Maus mit Kurven und Mikrokorrektionen:

import bezier
import numpy as np

def generate_human_mouse_path(start, end, num_points=50):
    """
    Generiert einen Mausweg, der menschlich aussieht,
    unter Verwendung von Bezier-Kurven mit leichtem Rauschen.
    """
    # Kontrollpunkte für die Bezier-Kurve
    control1 = (
        start[0] + (end[0] - start[0]) * random.uniform(0.2, 0.4) + random.randint(-50, 50),
        start[1] + (end[1] - start[1]) * random.uniform(0.2, 0.4) + random.randint(-50, 50)
    )
    control2 = (
        start[0] + (end[0] - start[0]) * random.uniform(0.6, 0.8) + random.randint(-50, 50),
        start[1] + (end[1] - start[1]) * random.uniform(0.6, 0.8) + random.randint(-50, 50)
    )
    
    # Erstellen Sie eine Bezier-Kurve
    nodes = np.asfortranarray([
        [start[0], control1[0], control2[0], end[0]],
        [start[1], control1[1], control2[1], end[1]]
    ])
    curve = bezier.Curve(nodes, degree=3)
    
    # Generieren Sie Punkte auf der Kurve
    points = []
    for t in np.linspace(0, 1, num_points):
        point = curve.evaluate(t)
        # Fügen Sie Mikrorauschen hinzu
        x = point[0][0] + random.uniform(-2, 2)
        y = point[1][0] + random.uniform(-2, 2)
        points.append((x, y))
    
    return points

async def human_click(page, selector):
    """Klickt auf ein Element mit menschenähnlicher Mausbewegung"""
    element = await page.query_selector(selector)
    box = await element.bounding_box()
    
    # Zielpunkt – nicht die Mitte, sondern ein zufälliger Punkt im Element
    target_x = box['x'] + random.uniform(box['width'] * 0.2, box['width'] * 0.8)
    target_y = box['y'] + random.uniform(box['height'] * 0.2, box['height'] * 0.8)
    
    # Aktuelle Mausposition (oder zufällige Startposition)
    start_x = random.randint(0, 1920)
    start_y = random.randint(0, 1080)
    
    # Generieren Sie den Weg
    path = generate_human_mouse_path((start_x, start_y), (target_x, target_y))
    
    # Bewegen Sie die Maus entlang des Weges
    for x, y in path:
        await page.mouse.move(x, y)
        await page.wait_for_timeout(random.randint(5, 20))
    
    # Kleine Pause vor dem Klick
    await page.wait_for_timeout(random.randint(50, 150))
    await page.mouse.click(target_x, target_y)

Ressourcenladung

Ein echter Browser lädt nicht nur HTML, sondern auch CSS, JavaScript, Bilder, Schriftarten. Wenn Sie Anfragen verwenden und nur HTML anfordern – das ist verdächtig. Bei der Arbeit mit Headless-Browsern wird dieses Problem automatisch gelöst, aber bei der Verwendung von HTTP-Clients müssen Sie diesen Moment berücksichtigen.

Auswahl des Proxy-Typs für die Aufgabe

Verschiedene Proxy-Typen haben unterschiedliche Eigenschaften und eignen sich für verschiedene Aufgaben. Die falsche Wahl ist eine häufige Ursache für Blockierungen.

Rechenzentrum-Proxys

Rechenzentrum-Proxys sind IP-Adressen, die Hosting-Anbietern gehören. Sie können leicht anhand der Zugehörigkeit zu AS (autonome Systeme) großer Rechenzentren identifiziert werden.

Vorteile:

• Hohe Geschwindigkeit und Stabilität
• Niedrige Kosten
• Große IP-Pools

Nachteile:

• Leicht zu erkennen
• Oft in schwarzen Listen
• Nicht geeignet für Websites mit ernsthaftem Schutz

Geeignet für: SEO-Tools, Verfügbarkeitsprüfung, Arbeit mit APIs ohne strengen Schutz, Tests.

Wohnproxys

Wohnproxys sind IP-Adressen echter Benutzer, die über Partnerprogramme oder SDKs in Anwendungen bereitgestellt werden. Sie gehören normalen Internetanbietern (ISP).

Vorteile:

• Sehen aus wie normale Benutzer
• Niedriger Fraud-Score
• Breite Geografie
• Schwer zu erkennen

Nachteile:

• Höhere Kosten (Zahlung pro Datenverkehr)
• Geschwindigkeit hängt vom Endbenutzer ab
• IPs können "verschwinden" (Benutzer hat das Gerät ausgeschaltet)

Geeignet für: Scraping geschützter Websites, Arbeit mit sozialen Netzwerken, E-Commerce, alle Aufgaben, bei denen es wichtig ist, nicht erkannt zu werden.

Mobile Proxys

Mobile Proxys sind IP-Adressen von Mobilfunkanbietern (MTS, Beeline, Megafon und Analoga in anderen Ländern). Sie haben einen besonderen Status aufgrund der CGNAT-Technologie.

Vorteile:

• Maximales Vertrauen von Websites
• Eine IP wird von Tausenden echten Benutzern verwendet – schwer zu bannen
• Ideal für die Kontoverwaltung
• IP-Wechsel auf Anfrage (Netzwerk-Neuverbindung)

Nachteile:

• Höchste Kosten
• Begrenzte Geschwindigkeit
• Weniger Geografieauswahl

Geeignet für: Multi-Accounting, Arbeit mit Instagram/Facebook/TikTok, Kontoregistrierung, alle Aufgaben mit hohem Sperrrisiko.

Vergleichstabelle

Fortgeschrittene Techniken zum Umgehen von Schutzmaßnahmen

Wenn grundlegende Methoden nicht funktionieren, müssen Sie komplexere Techniken verwenden. Lassen Sie uns mehrere fortgeschrittene Ansätze betrachten.

Arbeit mit Cloudflare und ähnlichen Schutzmaßnahmen

Cloudflare, Akamai, PerimeterX – diese Systeme verwenden JavaScript-Challenges zur Browser-Überprüfung. Eine einfache HTTP-Anfrage wird nicht durchgehen. Lösungsvarianten:

1. Verwendung eines echten Browsers:

from playwright.sync_api import sync_playwright

def bypass_cloudflare(url, proxy):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # Manchmal wird headless erkannt
            proxy={"server": proxy}
        )
        
        page = browser.new_page()
        page.goto(url)
        
        # Warten Sie auf die Überprüfung (normalerweise 5-10 Sekunden)
        page.wait_for_timeout(10000)
        
        # Überprüfen Sie, ob wir bestanden haben
        if "challenge" not in page.url:
            # Speichern Sie Cookies für nachfolgende Anfragen
            cookies = page.context.cookies()
            return cookies
        
        browser.close()
        return None

2. Verwendung fertiger Lösungen:

# cloudscraper – Bibliothek zum Umgehen von Cloudflare
import cloudscraper

scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

scraper.proxies = {"http": proxy, "https": proxy}
response = scraper.get("https://protected-site.com")

Captcha-Lösung

Wenn die Website eine Captcha anzeigt, gibt es mehrere Ansätze:

Erkennungsdienste: 2Captcha, Anti-Captcha, CapMonster. Sie lösen Captchas für Sie