Proxy gibt falsche Daten zurück: Ursachen und Lösungen

Sie haben den Parser eingerichtet, den Datensammelvorgang gestartet, und das Ergebnis sind Preise aus einer anderen Region, veraltete Inhalte oder eine komplett fremde Seite. Wir analysieren, warum ein Proxy falsche Daten zurückgeben kann und wie Sie das beheben.

1. Caching auf der Proxy-Seite

Die häufigste Ursache für veraltete Daten ist das Caching. Einige Proxy-Server speichern Antworten von Websites, um die Last zu reduzieren und die Geschwindigkeit zu erhöhen. Das Ergebnis: Sie erhalten Daten, die eine Woche alt sind, anstatt der aktuellen Informationen.

Wie man das Problem erkennt

• Die Daten ändern sich bei wiederholten Anfragen nicht
• Preise oder Produktverfügbarkeiten entsprechen nicht der Realität
• Der Header Age in der Antwort zeigt einen hohen Wert an

Lösung

Fügen Sie Header hinzu, die das Caching verbieten:

import requests

headers = {
    'Cache-Control': 'no-cache, no-store, must-revalidate',
    'Pragma': 'no-cache',
    'Expires': '0'
}

response = requests.get(
    'https://example.com/prices',
    proxies={'http': proxy, 'https': proxy},
    headers=headers
)

Wenn der Anbieter weiterhin Caching betreibt – fügen Sie einen zufälligen Parameter zur URL hinzu:

import time

url = f'https://example.com/prices?_nocache={int(time.time())}'

2. Nicht übereinstimmende Geolokalisierung

Sie fordern einen Proxy aus Deutschland an, erhalten aber Preise in Rubel. Oder Sie benötigen russische Daten, aber die Website zeigt Inhalte für die USA an. Dies geschieht aus mehreren Gründen.

Warum die Geolokalisierung nicht übereinstimmt

Lösung

Synchronisieren Sie alle Parameter der Anfrage mit der gewünschten Geolokalisierung:

# Für das Scraping einer deutschen Website
headers = {
    'Accept-Language': 'de-DE,de;q=0.9,en;q=0.8',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
}

# Saubere Sitzung ohne Cookies
session = requests.Session()
session.cookies.clear()

response = session.get(
    'https://example.de/preise',
    proxies={'http': german_proxy, 'https': german_proxy},
    headers=headers
)

Überprüfen Sie die tatsächliche Geolokalisierung der IP vor dem Scraping:

def check_proxy_geo(proxy):
    response = requests.get(
        'http://ip-api.com/json/',
        proxies={'http': proxy, 'https': proxy},
        timeout=10
    )
    data = response.json()
    return data.get('country'), data.get('city')

3. Probleme mit der IP-Rotation

Bei der Verwendung von Residenziellen Proxys mit automatischer Rotation ändert sich die IP zwischen den Anfragen. Dies ist nützlich, um Limits zu umgehen, führt aber zu Problemen, wenn Konsistenz erforderlich ist.

Typische Symptome

• Die Paginierung gibt Duplikate zurück oder überspringt Elemente
• Der Warenkorb wird zwischen den Anfragen geleert
• Die Authentifizierung wird mitten in der Sitzung aufgehoben
• A/B-Tests der Website zeigen unterschiedliche Versionen der Seiten

Lösung: Sticky Sessions

Die meisten Proxy-Anbieter unterstützen „Sticky Sessions“ – die IP bleibt für einen bestimmten Zeitraum erhalten. Dies wird normalerweise durch einen Parameter in der Verbindungszeichenfolge konfiguriert:

# Beispielformat mit Session-ID (Syntax hängt vom Anbieter ab)
proxy = 'http://user-session-abc123:pass@gate.provider.com:7777'

# Alle Anfragen mit derselben Session-ID gehen über dieselbe IP
for page in range(1, 10):
    response = requests.get(
        f'https://example.com/catalog?page={page}',
        proxies={'http': proxy, 'https': proxy}
    )

Wichtig: Sticky Sessions sind normalerweise 1–30 Minuten gültig. Planen Sie Ihre Datensammlung so, dass zusammengehörige Anfragen in dieses Zeitfenster fallen.

4. Verletzung von Sitzungen und Cookies

Moderne Websites verwenden Cookies intensiv zur Personalisierung. Wenn Ihr Parser diese nicht korrekt verarbeitet, erhalten Sie falsche Daten – oder werden direkt blockiert.

Häufige Fehler

1. Ignorieren von Set-Cookie – die Website kann die Sitzung nicht verfolgen
2. Wiederverwendung von Cookies mit einer anderen IP – verdächtiges Verhalten
3. Fehlender initialer Request – direkter Aufruf einer internen Seite ohne „Anmeldung“ über die Startseite

Der richtige Ansatz

import requests

def create_browser_session(proxy):
    session = requests.Session()
    session.proxies = {'http': proxy, 'https': proxy}
    
    # Imitieren des ersten Besuchs – Erhalten der Cookies
    session.get('https://example.com/', headers={
        'User-Agent': 'Mozilla/5.0...',
        'Accept': 'text/html,application/xhtml+xml...',
        'Accept-Language': 'en-US,en;q=0.9'
    })
    
    # Nun kann mit einer gültigen Sitzung gescraped werden
    return session

session = create_browser_session(proxy)
data = session.get('https://example.com/api/prices').json()

5. Kodierungs- und Komprimierungsfehler

Manchmal kommen die Daten korrekt an, werden aber aufgrund von Kodierungs- oder Komprimierungsproblemen falsch dargestellt. Dies ist besonders relevant beim Umgang mit kyrillischen und asiatischen Sprachen.

Symptome

• Kauderwelsch statt Text: Цена statt „Цена“
• Leere Antwort bei aktiviertem gzip
• Binärer Müll statt HTML

Lösung

import requests

response = requests.get(url, proxies=proxies)

# Methode 1: Automatische Kodierungserkennung
response.encoding = response.apparent_encoding
text = response.text

# Methode 2: Erzwingen der Kodierung
text = response.content.decode('utf-8')

# Methode 3: Deaktivieren der Komprimierung (falls der Proxy gzip beschädigt)
headers = {'Accept-Encoding': 'identity'}
response = requests.get(url, proxies=proxies, headers=headers)

6. Versteckte Blockaden und Captchas

Nicht alle Blockaden sind offensichtlich. Eine Website kann HTTP 200 zurückgeben, aber anstelle der tatsächlichen Daten einen Cache, eine veraltete Version oder eine Seite mit einem Captcha innerhalb des normalen HTML-Codes einschleusen.

Anzeichen einer versteckten Blockade

• Die Antwortgröße ist verdächtig klein oder für verschiedene Seiten gleich
• Im HTML finden sich die Wörter: captcha, challenge, blocked, access denied
• Erwartete Elemente (Preise, Beschreibungen, Schaltflächen) fehlen
• JavaScript-Weiterleitung auf eine andere Seite

Antwortvalidierung

def is_valid_response(response, expected_markers):
    """Prüft, ob die Antwort echte Daten enthält"""
    
    text = response.text.lower()
    
    # Prüfung auf Blockierungssignale
    block_signals = ['captcha', 'blocked', 'access denied', 
                     'rate limit', 'try again later']
    for signal in block_signals:
        if signal in text:
            return False, f'Blockiert: {signal}'
    
    # Prüfung auf das Vorhandensein erwarteter Daten
    for marker in expected_markers:
        if marker.lower() not in text:
            return False, f'Fehlt: {marker}'
    
    # Prüfung der Größe (zu klein = Platzhalter)
    if len(response.content) < 5000:
        return False, 'Antwort zu klein'
    
    return True, 'OK'

# Verwendung
valid, reason = is_valid_response(response, ['price', 'add to cart'])
if not valid:
    print(f'Ungültige Antwort: {reason}')
    # Proxy wechseln, warten, erneut versuchen

Für Websites mit starkem Bot-Schutz bieten Mobile Proxys ein höheres Vertrauensniveau als Rechenzentrums-Proxys.

7. Schrittweise Diagnose

Wenn ein Proxy falsche Daten zurückgibt, verwenden Sie diesen Algorithmus, um die Ursache zu finden:

Schritt 1: Problem isolieren

# Vergleichen Sie die Antworten: ohne Proxy vs. mit Proxy
def compare_responses(url, proxy):
    direct = requests.get(url)
    proxied = requests.get(url, proxies={'http': proxy, 'https': proxy})
    
    print(f'Direkt:  {len(direct.content)} Bytes, Status {direct.status_code}')
    print(f'Proxy:   {len(proxied.content)} Bytes, Status {proxied.status_code}')
    
    # Speichern Sie beide Antworten zum Vergleich
    with open('direct.html', 'w') as f:
        f.write(direct.text)
    with open('proxied.html', 'w') as f:
        f.write(proxied.text)

Schritt 2: Überprüfen Sie die Antwort-Header

response = requests.get(url, proxies=proxies)

# Wichtige Header für die Diagnose
important_headers = ['content-type', 'content-encoding', 
                     'cache-control', 'age', 'x-cache', 
                     'cf-ray', 'server']

for header in important_headers:
    value = response.headers.get(header, 'nicht gesetzt')
    print(f'{header}: {value}')

Schritt 3: Checkliste der Überprüfungen

Schritt 4: Vollständiges Diagnose-Skript

import requests
import json

def diagnose_proxy(proxy, target_url):
    report = {}
    
    # 1. Funktionsprüfung
    try:
        r = requests.get('http://httpbin.org/ip', 
                        proxies={'http': proxy, 'https': proxy},
                        timeout=15)
        report['proxy_ip'] = r.json().get('origin')
        report['proxy_works'] = True
    except Exception as e:
        report['proxy_works'] = False
        report['error'] = str(e)
        return report
    
    # 2. Geolokalisierung
    r = requests.get('http://ip-api.com/json/',
                    proxies={'http': proxy, 'https': proxy})
    geo = r.json()
    report['country'] = geo.get('country')
    report['city'] = geo.get('city')
    
    # 3. Anfrage an die Zielseite
    r = requests.get(target_url,
                    proxies={'http': proxy, 'https': proxy},
                    timeout=30)
    report['status_code'] = r.status_code
    report['content_length'] = len(r.content)
    report['cached'] = 'age' in r.headers or 'x-cache' in r.headers
    
    # 4. Prüfung auf Blockierung
    block_words = ['captcha', 'blocked', 'denied', 'cloudflare']
    report['possibly_blocked'] = any(w in r.text.lower() for w in block_words)
    
    return report

# Verwendung
result = diagnose_proxy('http://user:pass@proxy:port', 'https://target-site.com')
print(json.dumps(result, indent=2))

Fazit

Falsche Daten vom Proxy sind fast immer ein lösbares Problem. In den meisten Fällen liegt die Ursache im Caching, einer nicht übereinstimmenden Geolokalisierung oder einer fehlerhaften Sitzungsverwaltung. Nutzen Sie das Diagnose-Skript aus diesem Artikel, um die Fehlerquelle schnell zu identifizieren.

Für Aufgaben, bei denen die Genauigkeit der Geolokalisierung und eine geringe Blockierungsrate entscheidend sind, sind Residenzielle Proxys mit Sticky-Session-Unterstützung optimal – mehr dazu auf proxycove.com.