So erstellst du einen IPRoyal-Proxy-Checker für HTTP, SOCKS5 und Shadowsocks

Überblick

IPRoyal bietet Residential-, Datacenter- und ISP-Proxys mit Unterstützung für HTTP-, SOCKS5- und Shadowsocks-Protokolle. Ob du Scraping betreibst, Suchergebnisse überwachst oder privat surfst, musst du wissen, dass deine Proxys erreichbar, schnell sind und nicht deine echte IP preisgeben. Eine manuelle Prüfung jedes Endpunkts skaliert nicht. Dieses Tutorial zeigt dir, wie du einen wiederverwendbaren Proxy-Checker in Python erstellst, der Konnektivität testet, Latenz misst und Anonymität für jeden IPRoyal-Endpunkt überprüft.

Voraussetzungen

• Python 3.8 oder neuer auf deinem System installiert.
• pip-Paketmanager.
• IPRoyal-Proxy-Zugangsdaten (Host, Port, Benutzername, Passwort). Du kannst diese aus dem IPRoyal-Dashboard kopieren.
• Für Shadowsocks-Tests: einen Shadowsocks-Client wie shadowsocks-libev (Linux/macOS) oder shadowsocks-rust.
• Grundlegende Vertrautheit mit der Kommandozeile und Python.

Verstehen, was geprüft werden muss

Ein nützlicher Proxy-Checker sollte vier Fragen beantworten:

• Konnektivität: Kann der Proxy das öffentliche Internet erreichen?
• Anonymität: Stimmt die vom Dienst zurückgegebene Exit-IP mit der Proxy-IP überein (nicht mit deiner echten IP)?
• Latenz: Wie lange dauert eine Anfrage von Anfang bis Ende?
• DNS-Verhalten: Werden DNS-Anfragen über den Proxy oder lokal aufgelöst? (Ein Leck verrät deinen echten Standort.)

Verschiedene Protokolle erfordern eine etwas unterschiedliche Handhabung. Die folgende Tabelle fasst den Ansatz für jedes IPRoyal-Protokoll zusammen.

Schritte

1. Python-Abhängigkeiten installieren

Die requests-Bibliothek verarbeitet HTTP- und HTTPS-Proxys. Für SOCKS5 benötigst du zusätzlich requests[socks] und pysocks.

pip install requests requests[socks] pysocks

2. IPRoyal-Proxy-Endpunkte sammeln

Melde dich im IPRoyal-Dashboard an und kopiere die Proxy-Liste. Die meisten Listen enthalten Zeilen im Format:

host:port:username:password

Speichere die Liste in einer einfachen Textdatei, zum Beispiel proxies.txt. Wenn du ein anderes Format verwendest, passe den Parsing-Code in den nächsten Schritten an.

3. Einen einfachen HTTP-Proxy-Checker schreiben

Erstelle eine Datei namens checker.py. Das folgende Snippet testet einen einzelnen HTTP-Proxy und gibt die zurückgegebene IP aus.

import requests
from requests.exceptions import ProxyError, ConnectTimeout

proxy_url = "http://username:password@host:port"
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

try:
    response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
    response.raise_for_status()
    print("Proxy works. Your IP appears as:", response.json()["origin"])
except (ProxyError, ConnectTimeout) as e:
    print("Proxy failed:", e)

Ersetze username, password, host und port durch deine IPRoyal-Zugangsdaten.

4. Den Checker um SOCKS5 erweitern

Für SOCKS5 ändere das Schema zu socks5h://. Das h weist requests an, DNS über den Proxy aufzulösen, was DNS-Leaks verhindert.

proxy_url = "socks5h://username:password@host:port"
proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

Führe denselben Anfrageblock aus. Wenn du einen Fehler Missing dependencies for SOCKS support siehst, installiere requests[socks] neu.

5. Latenzmessung und IP-Überprüfung hinzufügen

Ändere das Skript, um die Anfrage zu messen und die zurückgegebene IP mit der erwarteten Proxy-IP zu vergleichen. Du kannst die erwartete IP in deiner Proxy-Liste speichern oder separat abrufen.

import time

start = time.time()
response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
elapsed = time.time() - start
returned_ip = response.json()["origin"]
print(f"Latency: {elapsed:.2f}s, Returned IP: {returned_ip}")

Wenn die zurückgegebene IP mit deiner echten IP übereinstimmt, anonymisiert der Proxy deinen Datenverkehr nicht. Überprüfe deine Authentifizierungs- und Protokolleinstellungen.

6. Shadowsocks-Endpunkte testen

Shadowsocks ist ein Tunnel, kein direktes Proxy-Protokoll. Um einen IPRoyal-Shadowsocks-Endpunkt zu prüfen, starte einen lokalen Shadowsocks-Client, der einen SOCKS5-Proxy bereitstellt, und teste dann diese lokale SOCKS5-Adresse.

Installiere shadowsocks-libev unter Linux oder macOS (über Homebrew). Erstelle dann eine Konfigurationsdatei ss-local.json:

{
  "server": "your_iproyal_ss_server",
  "server_port": 8388,
  "local_address": "127.0.0.1",
  "local_port": 1080,
  "password": "your_password",
  "method": "aes-256-gcm"
}

Starte den Client:

ss-local -c ss-local.json

Behandle nun socks5h://127.0.0.1:1080 als deinen Proxy im Checker-Skript. Wenn die Verbindung funktioniert, arbeitet der Shadowsocks-Tunnel.

7. Einen Batch-Checker mit Rotation und Protokollierung erstellen

Für mehrere Proxys parse deine Datei proxies.txt, durchlaufe jeden Endpunkt und protokolliere die Ergebnisse in einer CSV-Datei. Das hilft dir, tote IPs zu identifizieren und die Leistung im Laufe der Zeit zu verfolgen.

import csv

with open("proxies.txt") as f:
    lines = [line.strip() for line in f if line.strip()]

results = []
for line in lines:
    host, port, user, pwd = line.split(":")
    proxy_url = f"socks5h://{user}:{pwd}@{host}:{port}"
    proxies = {"http": proxy_url, "https": proxy_url}
    try:
        start = time.time()
        r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
        elapsed = time.time() - start
        ip = r.json()["origin"]
        results.append((host, port, "OK", f"{elapsed:.2f}", ip))
    except Exception as e:
        results.append((host, port, "FAIL", "", str(e)))

with open("proxy_report.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Host", "Port", "Status", "Latency(s)", "Returned IP/Error"])
    writer.writerows(results)

Führe das Skript regelmäßig aus, um einen gesunden Proxy-Pool zu erhalten.

Fehlerbehebung

• 407 Proxy Authentication Required: Überprüfe den Benutzernamen und das Passwort. Wenn dein Passwort Sonderzeichen wie @ oder : enthält, URL-kodiere sie (z. B. wird @ zu %40).
• Verbindungszeitüberschreitung: Prüfe, ob Host und Port korrekt sind und ob deine IP im IPRoyal-Dashboard auf der Whitelist steht, falls dein Tarif dies erfordert.
• SOCKS5-Fehler: Stelle sicher, dass requests[socks] installiert ist. Verwende socks5h:// für die Remote-DNS-Auflösung; socks5:// löst DNS lokal auf.
• Shadowsocks-Client startet nicht: Bestätige, dass die Verschlüsselungsmethode mit deiner IPRoyal-Konfiguration übereinstimmt und dass der Serverport geöffnet ist. Teste mit ss-local -c ss-local.json -v für ausführliche Ausgaben.
• DNS-Leaks: Verwende socks5h:// und teste mit einem DNS-Leak-Testdienst über den Proxy. Wenn der Standort des Resolvers vom Standort des Proxys abweicht, tritt ein DNS-Leak auf.
• HTTPS-Zertifikatfehler: Einige Proxys fangen TLS ab. Bevorzuge für Scraping Residential- oder ISP-Proxys, die End-to-End-HTTPS ohne Abfangen unterstützen.

Zusammenfassung

Du hast einen Python-basierten Proxy-Checker erstellt, der HTTP-, SOCKS5- und Shadowsocks-Endpunkte von IPRoyal validiert. Das Skript misst die Latenz, überprüft die Exit-IP und protokolliert Ergebnisse für die Batch-Analyse. Regelmäßige Prüfungen helfen dir, tote Proxys auszusortieren und zuverlässige Scraping- oder Datenschutz-Workflows aufrechtzuerhalten. Die breite Protokollunterstützung von IPRoyal macht es zu einer flexiblen Wahl für diese Aufgaben, und der Checker kann durch Ändern des Proxy-Listenformats an jeden Anbieter angepasst werden.