Proxy-Einstellungen in curl und wget: Eine vollständige Anleitung

Beim Scraping von Websites, der Automatisierung von API-Anfragen oder der Überwachung von Preisen von Wettbewerbern auf Marktplätzen werden Sie unweigerlich mit IP-Sperren konfrontiert. Die Tools curl und wget sind Standardwerkzeuge für die Arbeit mit HTTP-Anfragen in der Befehlszeile, und die richtige Konfiguration von Proxys ist entscheidend, um Einschränkungen zu umgehen. In diesem Artikel werden wir alle Möglichkeiten zur Verwendung von Proxys in curl und wget untersuchen: von grundlegenden Befehlen bis hin zu fortgeschrittenen Szenarien mit IP-Rotation und Fehlerbehandlung.

Grundsyntax für Proxys in curl und wget

Beginnen wir mit den einfachsten Befehlen zur Verbindung über einen Proxy. Beide Tools unterstützen einen Parameter zur Angabe des Proxy-Servers, aber die Syntax unterscheidet sich leicht.

Verwendung von Proxys in curl

In curl wird der Proxy über den Parameter -x oder --proxy angegeben. Das grundlegende Format des Befehls lautet:

curl -x http://proxy-server:port http://example.com

Ein konkretes Beispiel mit einem echten Proxy-Server:

curl -x http://45.130.123.45:8080 http://api.ipify.org

Dieser Befehl sendet eine Anfrage an api.ipify.org (ein Dienst, der Ihre IP-Adresse zurückgibt) über den angegebenen Proxy-Server. Sie sehen die IP des Proxys und nicht Ihre tatsächliche Adresse.

Verwendung von Proxys in wget

In wget wird der Proxy über den Parameter -e use_proxy=yes und Umgebungsvariablen konfiguriert, oder direkt über Optionen:

wget -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 http://example.com

Oder eine kürzere Variante über Umgebungsvariablen (darüber mehr im folgenden Abschnitt):

export http_proxy="http://45.130.123.45:8080"
wget http://example.com

Authentifizierung am Proxy-Server

Die meisten kommerziellen Proxy-Dienste erfordern eine Authentifizierung mit Benutzername und Passwort. Dies schützt den Proxy vor unbefugter Nutzung und ermöglicht es, den Datenverkehr jedes Kunden zu verfolgen. Lassen Sie uns sehen, wie Sie Anmeldeinformationen in curl und wget übergeben.

Authentifizierung in curl

In curl können Sie Benutzername und Passwort direkt in der URL des Proxy-Servers oder über einen separaten Parameter -U angeben:

# Methode 1: Benutzername und Passwort in der URL
curl -x http://username:password@proxy-server:port http://example.com

# Methode 2: über den Parameter -U
curl -x http://proxy-server:port -U username:password http://example.com

Ein konkretes Beispiel mit Anmeldeinformationen:

curl -x http://user123:pass456@45.130.123.45:8080 http://api.ipify.org

Ein wichtiger Punkt: Wenn das Passwort Sonderzeichen enthält (@, :, /, ?), müssen diese im URL-Format kodiert werden. Zum Beispiel wird das Zeichen @ durch %40 ersetzt:

# Wenn das Passwort @ enthält: pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

Authentifizierung in wget

In wget wird die Authentifizierung über die Parameter --proxy-user und --proxy-password konfiguriert:

wget --proxy-user=username --proxy-password=password \
     -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 \
     http://example.com

Oder über Umgebungsvariablen mit Anmeldeinformationen in der URL:

export http_proxy="http://username:password@45.130.123.45:8080"
wget http://example.com

Arbeiten mit verschiedenen Proxy-Typen: HTTP, HTTPS, SOCKS5

Proxy-Server arbeiten mit verschiedenen Protokollen, und die Wahl des Typs hängt von der Aufgabe ab. HTTP-Proxys eignen sich für einfache Anfragen, HTTPS bieten Verschlüsselung, und SOCKS5 arbeiten auf einer niedrigeren Ebene und unterstützen jeden Datenverkehr. Beim Scraping von Marktplätzen wie Wildberries oder Ozon werden häufig residential Proxys verwendet, die mit jedem dieser Protokolle arbeiten können.

HTTP- und HTTPS-Proxys

HTTP-Proxys sind der am weitesten verbreitete Typ. Sie arbeiten auf der Ebene des HTTP-Protokolls und eignen sich für die meisten Aufgaben des Web-Scrapings:

# HTTP-Proxy in curl
curl -x http://proxy-server:8080 http://example.com

# HTTPS-Proxy in curl (für sichere Verbindungen)
curl -x https://proxy-server:8080 https://example.com

Wichtig: Selbst wenn die Zielwebsite HTTPS verwendet, kann der Proxy HTTP sein. Curl stellt automatisch einen Tunnel über die CONNECT-Methode her:

# HTTP-Proxy für eine HTTPS-Website (funktioniert korrekt)
curl -x http://proxy-server:8080 https://secure-site.com

SOCKS5-Proxys

SOCKS5 ist ein universelleres Protokoll, das auf der TCP-Ebene arbeitet und jeden Datentyp (HTTP, HTTPS, FTP, sogar UDP) unterstützt. Das macht SOCKS5 zur idealen Wahl für komplexe Automatisierungsaufgaben:

# SOCKS5 in curl
curl -x socks5://proxy-server:1080 http://example.com

# SOCKS5 mit Authentifizierung
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (DNS-Resolution über den Proxy)
curl -x socks5h://proxy-server:1080 http://example.com

Der Unterschied zwischen socks5 und socks5h: Im ersten Fall gehen DNS-Anfragen von Ihrem Computer aus, im zweiten über den Proxy-Server. Verwenden Sie socks5h, wenn Sie Ihre Aktivitäten, einschließlich DNS-Anfragen, vollständig verbergen möchten.

In wget ist die Unterstützung für SOCKS5 begrenzt, daher ist es besser, curl oder zusätzliche Tools wie proxychains für solche Aufgaben zu verwenden.

Hinweis: Für das Scraping von Marktplätzen (Wildberries, Ozon, Yandex.Market) wird empfohlen, residential oder mobile Proxys mit HTTP/HTTPS-Protokoll zu verwenden — sie werden seltener blockiert, da sie IP-Adressen realer Benutzer haben.

Proxy-Konfiguration über Umgebungsvariablen

Wenn Sie regelmäßig über einen Proxy arbeiten, ist es bequemer, die Umgebungsvariablen einmal einzurichten, als die Parameter in jedem Befehl anzugeben. Curl und wget lesen diese Variablen automatisch.

Einstellung für die aktuelle Sitzung

Exportieren Sie die Variablen im Terminal (gilt bis zur Schließung der Sitzung):

# Für HTTP-Datenverkehr
export http_proxy="http://username:password@proxy-server:8080"

# Für HTTPS-Datenverkehr
export https_proxy="http://username:password@proxy-server:8080"

# Für FTP-Datenverkehr
export ftp_proxy="http://username:password@proxy-server:8080"

# Für SOCKS5
export all_proxy="socks5://username:password@proxy-server:1080"

Danach verwenden curl und wget automatisch den Proxy:

# Proxy wird automatisch angewendet
curl http://api.ipify.org
wget http://example.com

Dauerhafte Einstellung in .bashrc oder .zshrc

Damit Proxys bei jedem Start des Terminals angewendet werden, fügen Sie die Variablen in die Konfigurationsdatei Ihrer Shell ein:

# Öffnen Sie die Datei im Editor
nano ~/.bashrc  # für bash
# oder
nano ~/.zshrc   # für zsh

# Fügen Sie am Ende der Datei hinzu:
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# Speichern Sie die Änderungen und wenden Sie sie an:
source ~/.bashrc

Ausnahmen: no_proxy

Manchmal müssen bestimmte Adressen vom Proxy ausgeschlossen werden (z. B. localhost oder interne Dienste):

export no_proxy="localhost,127.0.0.1,192.168.0.0/16,.local"

Jetzt werden Anfragen an diese Adressen direkt und ohne Proxy gesendet.

Proxy-Rotation in Bash-Skripten

Beim massenhaften Scraping (z. B. beim Sammeln von Preisen von Tausenden von Produktkarten auf Wildberries) führt die Verwendung eines einzigen Proxys zu einer Sperre. Die Lösung ist die Rotation von IP-Adressen. Lassen Sie uns sehen, wie Sie dies in Bash-Skripten umsetzen können.

Einfache Rotation aus einer Proxy-Liste

Erstellen Sie eine Datei proxies.txt mit einer Liste von Proxy-Servern (einen pro Zeile):

http://user1:pass1@proxy1.example.com:8080
http://user2:pass2@proxy2.example.com:8080
http://user3:pass3@proxy3.example.com:8080

Skript zur sequenziellen Rotation von Proxys:

#!/bin/bash

# Datei mit der Liste von URLs zum Scraping
urls_file="urls.txt"
# Datei mit der Liste von Proxys
proxies_file="proxies.txt"

# Lesen Sie Proxys in ein Array
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# Verarbeiten Sie jede URL
while IFS= read -r url; do
    # Wählen Sie den Proxy im Kreis
    proxy="${proxies[$current_proxy]}"
    
    echo "Anfrage an $url über $proxy"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # Wechseln Sie zum nächsten Proxy
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # Pause zwischen den Anfragen (1-3 Sekunden)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

Dieses Skript verwendet nacheinander Proxys aus der Liste und kehrt nach dem letzten Proxy zum ersten zurück. Eine zufällige Pause zwischen den Anfragen macht die Aktivität natürlicher.

Zufällige Auswahl von Proxys

Für mehr Unvorhersehbarkeit können Sie Proxys zufällig auswählen:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}

while IFS= read -r url; do
    # Zufällige Auswahl eines Proxys
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "Anfrage an $url über Proxy #$random_index"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

Automatische Rotation über die API des Proxy-Dienstes

Viele Proxy-Anbieter (einschließlich Dienste, die residential Proxys bereitstellen) bieten eine automatische Rotation über einen einzigen Zugangspunkt an. Sie verwenden eine Proxy-Adresse, während sich die IP bei jeder Anfrage oder nach einem Timer ändert:

# Proxy mit automatischer Rotation
# IP ändert sich bei jeder Anfrage
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org

# Die beiden obigen Anfragen erhalten unterschiedliche IP-Adressen

Dies ist der bequemste Weg für massives Scraping — Sie müssen die Liste der Proxys nicht manuell verwalten.

Übertragung von Headern und User-Agent über Proxys

Moderne Websites analysieren nicht nur die IP-Adresse, sondern auch die HTTP-Header der Anfrage. Das Fehlen eines User-Agent oder verdächtige Header können sogar bei der Verwendung hochwertiger Proxys zu einer Sperre führen. Lassen Sie uns sehen, wie Sie die Header in curl und wget richtig einstellen.

User-Agent in curl

Der User-Agent ist ein Header, der den Browser und das Betriebssystem identifiziert. Curl sendet standardmäßig seinen eigenen User-Agent (curl/7.x.x), was sofort auf die Automatisierung hinweist. Ersetzen Sie ihn durch einen realen Browser:

# Chrome unter Windows
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
     http://example.com

# Firefox unter macOS
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0" \
     http://example.com

Zusätzliche Header

Für eine realistischere Anfrage fügen Sie typische Browser-Header hinzu:

curl -x http://proxy:8080 \
     -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
     -H "Accept-Language: ru-RU,ru;q=0.9,en;q=0.8" \
     -H "Accept-Encoding: gzip, deflate, br" \
     -H "Connection: keep-alive" \
     -H "Upgrade-Insecure-Requests: 1" \
     http://example.com

User-Agent in wget

In wget wird der User-Agent über den Parameter --user-agent festgelegt:

wget --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -e use_proxy=yes -e http_proxy=http://proxy:8080 \
     http://example.com

Randomisierung des User-Agent in Skripten

Für massives Scraping ist es nützlich, den User-Agent zu wechseln, damit die Anfragen wie von verschiedenen Benutzern aussehen:

#!/bin/bash

# Array von User-Agents
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
    "Mozilla/5.0 (X11; Linux x86_64) Firefox/121.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari/604.1"
)

while IFS= read -r url; do
    # Zufälliger User-Agent
    random_ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x http://proxy:8080 -A "$random_ua" -s "$url"
    sleep 2
done < "urls.txt"

Fehlerdiagnose und Fehlerbehandlung

Bei der Arbeit mit Proxys treten häufig Fehler auf: Zeitüberschreitungen, Verbindungsabbrüche, falsche Authentifizierung. Lassen Sie uns sehen, wie Sie diese Situationen diagnostizieren und behandeln können.

Überprüfung der Funktionsfähigkeit des Proxys

Der einfachste Weg, einen Proxy zu überprüfen, besteht darin, einen Dienst anzufordern, der Ihre IP zurückgibt:

# Überprüfung des HTTP-Proxys
curl -x http://proxy:8080 http://api.ipify.org

# Überprüfung des SOCKS5-Proxys
curl -x socks5://proxy:1080 http://api.ipify.org

# Mit detaillierten Informationen
curl -x http://proxy:8080 -v http://api.ipify.org

Der Parameter -v (verbose) zeigt die Details der Verbindung, einschließlich Header und Fehler.

Behandlung von Zeitüberschreitungen

Langsame Proxys oder überlastete Server können Zeitüberschreitungen verursachen. Setzen Sie angemessene Zeitlimits:

# Verbindungszeitüberschreitung 10 Sekunden, Gesamtlaufzeit 30 Sekunden
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

# In wget
wget --timeout=30 --tries=3 -e http_proxy=http://proxy:8080 http://example.com

Automatische Fehlerbehandlung in Skripten

Skript zum Scraping mit automatischem Wechsel zum nächsten Proxy bei einem Fehler:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"

fetch_with_retry() {
    local url=$1
    local max_attempts=3
    
    for proxy in "${proxies[@]}"; do
        echo "Versuch über Proxy: $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "Erfolg mit Proxy: $proxy"
            return 0
        else
            echo "Fehler mit Proxy: $proxy, versuchen Sie den nächsten"
        fi
    done
    
    echo "Alle Proxys sind für $url nicht verfügbar"
    return 1
}

# Verwendung
fetch_with_retry "http://example.com/page1"

Der Parameter -f zwingt curl, bei HTTP-Status 4xx und 5xx einen Fehler zurückzugeben, was es ermöglicht, nicht nur Netzwerkfehler, sondern auch Sperren auf Anwendungsebene zu behandeln.

Protokollierung zur Fehlersuche

Speichern Sie detaillierte Protokolle der Anfragen zur Analyse von Problemen:

# Speichern der Antwort-Header
curl -x http://proxy:8080 -D headers.txt http://example.com

# Vollständiges Protokoll der Interaktion
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

# Nur HTTP-Status
curl -x http://proxy:8080 -o /dev/null -s -w "%{http_code}\n" http://example.com

Praktische Anwendungsfälle

Lassen Sie uns reale Aufgaben betrachten, bei denen curl und wget mit Proxys spezifische Geschäftsprobleme lösen.

Scraping von Wettbewerberpreisen auf Marktplätzen

Aufgabe: Preise für 500 Produkte von Wettbewerbern auf Wildberries sammeln, um die Preisstrategie zu analysieren. Wildberries blockiert aktiv massenhafte Anfragen von einer IP.

Lösung: Verwendung von residential Proxys mit Rotation und Randomisierung des User-Agent:

#!/bin/bash

# Proxy mit automatischer Rotation
PROXY="http://user:pass@rotating-residential.proxy.com:8080"

# Array von User-Agents
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1"
)

# Lesen Sie die Produkt-IDs aus der Datei
while IFS= read -r product_id; do
    ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x "$PROXY" \
         -A "$ua" \
         -H "Accept-Language: ru-RU,ru;q=0.9" \
         -s "https://www.wildberries.ru/catalog/${product_id}/detail.aspx" \
         -o "products/${product_id}.html"
    
    echo "Produkt $product_id heruntergeladen"
    sleep $((RANDOM % 5 + 3))  # Pause 3-8 Sekunden
done < product_ids.txt

Überwachung der API-Verfügbarkeit aus verschiedenen Regionen

Aufgabe: Überprüfen, wie die API Ihres Dienstes für Benutzer aus verschiedenen Ländern funktioniert (Geoblockierungen, Antwortgeschwindigkeit).

Lösung: Proxys mit IPs aus den benötigten Ländern:

#!/bin/bash

# Proxys aus verschiedenen Ländern
declare -A proxies=(
    ["US"]="http://user:pass@us-proxy.com:8080"
    ["DE"]="http://user:pass@de-proxy.com:8080"
    ["JP"]="http://user:pass@jp-proxy.com:8080"
)

API_URL="https://api.yourservice.com/v1/status"

for country in "${!proxies[@]}"; do
    echo "Überprüfung aus $country..."
    
    response_time=$(curl -x "${proxies[$country]}" \
                         -s -o /dev/null \
                         -w "%{time_total}" \
                         "$API_URL")
    
    http_code=$(curl -x "${proxies[$country]}" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     "$API_URL")
    
    echo "$country: HTTP $http_code, Antwortzeit ${response_time}s"
done

Herunterladen von Dateien über wget mit Proxy-Rotation

Aufgabe: Ein Archiv von Dateien (Produktbilder, Dokumente) von einer Website herunterladen, die die Geschwindigkeit für eine IP einschränkt.

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current=0

while IFS= read -r file_url; do
    proxy="${proxies[$current]}"
    filename=$(basename "$file_url")
    
    echo "Herunterladen von $filename über Proxy #$current"
    
    wget --proxy-user=username --proxy-password=password \
         -e use_proxy=yes -e http_proxy="$proxy" \
         -O "downloads/$filename" \
         "$file_url"
    
    current=$(( (current + 1) % proxy_count ))
    sleep 2
done < file_urls.txt

Testen von Werbekreativen in verschiedenen GEO

Aufgabe: Überprüfen, wie Facebook Ads-Anzeigen für Benutzer aus den USA, Kanada und Großbritannien aussehen (verschiedene Währungen, Sprachen, Verfügbarkeit von Angeboten).

#!/bin/bash

# Mobile Proxys aus verschiedenen Ländern für Realismus
declare -A mobile_proxies=(
    ["US"]="http://user:pass@us-mobile.proxy.com:8080"
    ["CA"]="http://user:pass@ca-mobile.proxy.com:8080"
    ["GB"]="http://user:pass@gb-mobile.proxy.com:8080"
)

AD_URL="https://www.facebook.com/ads/library/?id=YOUR_AD_ID"

for country in "${!mobile_proxies[@]}"; do
    curl -x "${mobile_proxies[$country]}" \
         -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1" \
         -H "Accept-Language: en-US,en;q=0.9" \
         -s "$AD_URL" \
         -o "ads_preview_${country}.html"
    
    echo "Vorschau für $country gespeichert"
done

Für solche Aufgaben sind mobile Proxys besonders effektiv, da sie echte Smartphone-Benutzer imitieren und seltener Verdacht bei Facebooks Anti-Fraud-Systemen erregen.

Wichtig für Arbitrageure: Verwenden Sie bei der Überprüfung von Werbekreativen über Proxys mobile IPs und die entsprechenden User-Agents mobiler Geräte. Facebook analysiert die Konsistenz der Daten (der Gerätetyp im User-Agent sollte mit dem IP-Typ übereinstimmen).

Automatisierung der Überprüfung der Website-Verfügbarkeit

Aufgabe: Überwachung der Verfügbarkeit Ihrer Website alle 5 Minuten, während Anfragen von echten Benutzern (nicht von der Server-IP) simuliert werden.

#!/bin/bash

PROXY="http://user:pass@residential.proxy.com:8080"
SITE_URL="https://yoursite.com"
LOG_FILE="uptime.log"

while true; do
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    http_code=$(curl -x "$PROXY" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     --max-time 10 \
                     "$SITE_URL")
    
    if [ "$http_code" -eq 200 ]; then
        echo "[$timestamp] OK - HTTP $http_code" >> "$LOG_FILE"
    else
        echo "[$timestamp] ERROR - HTTP $http_code" >> "$LOG_FILE"
        # Senden Sie eine Benachrichtigung (z. B. über die Telegram-API)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=Website nicht verfügbar: HTTP $http_code"
    fi
    
    sleep 300  # 5 Minuten
done

Fazit

Curl und wget sind leistungsstarke Werkzeuge zur Automatisierung von HTTP-Anfragen, und die richtige Konfiguration von Proxys macht sie unverzichtbar für Scraping, Überwachung und Tests. Wir haben alle wichtigen Aspekte behandelt: von der grundlegenden Syntax bis hin zu fortgeschrittenen Szenarien mit IP-Rotation, Fehlerbehandlung und Randomisierung von Headern.

Die wichtigsten Erkenntnisse aus dem Artikel:

Verwenden Sie den Parameter -x in curl und Umgebungsvariablen zur Konfiguration von Proxys
Wählen Sie den Proxy-Typ je nach Aufgabe: HTTP für einfache Anfragen, SOCKS5 für Vielseitigkeit
Ersetzen Sie immer den Standard-User-Agent durch einen realistischen Browser-User-Agent
Implementieren Sie die Proxy-Rotation für massives Scraping — dies ist entscheidend, um Sperren zu umgehen
Fügen Sie Fehler- und Zeitüberschreitungsbehandlung in Produktionsskripte ein
Verwenden Sie zufällige Pausen zwischen Anfragen, um menschliches Verhalten zu simulieren

Für Aufgaben, die ein hohes Maß an Anonymität und minimales Risiko von Sperren erfordern (Scraping von Marktplätzen, Überprüfung von Werbung, Überwachung von Wettbewerbern), empfehlen wir die Verwendung von residential Proxys. Sie haben IPs echter Haushaltsbenutzer, was Ihre Anfragen von normalem Datenverkehr nicht unterscheidbar macht und die Wahrscheinlichkeit, auf Sperrlisten zu gelangen, erheblich verringert.

Jetzt haben Sie ein vollständiges Set an Werkzeugen und Wissen für die effektive Arbeit mit Proxys in curl und wget. Wenden Sie diese Techniken in Ihren Projekten an, passen Sie die Beispiele an spezifische Aufgaben an und skalieren Sie die Automatisierung ohne Angst vor Sperren.

Proxy-Einstellungen in curl und wget: Ultimative Anleitung mit Beispielen für das Scraping