Proxys in PowerShell verwenden: Invoke-WebRequest & Invoke-RestMethod Leitfaden

Wenn Sie als Windows-Admin oder Automatisierungsengineer Daten von Web-APIs abrufen, stoßen Sie früher oder später auf IP-Sperren, Rate-Limits und CAPTCHAs. Proxys in PowerShell verwenden zu können, ist daher eine Kernkompetenz — egal ob Sie SERP-Daten sammeln, Preise überwachen oder interne Endpunkte testen. Dieser Leitfaden zeigt Ihnen, wie Sie Invoke-WebRequest und Invoke-RestMethod mit ProxyHat kombinieren, um robuste, rotierende Proxy-Verbindungen in PowerShell aufzubauen.

Warum Proxys in PowerShell notwendig sind

Viele moderne Web-APIs und Scraping-Ziele blockieren Anfragen aus bekannten Rechenzentr-IP-Bereichen von Cloud-Anbietern wie Azure oder AWS. Wenn Ihr Skript von einer Azure-VM oder einem Unternehmensnetzwerk mit statischer IP läuft, kann der Zielserver Ihre Anfrage bereits auf TCP-Ebene ablehnen. Residential Proxys verwenden IPs, die von echten ISPs vergeben werden, und sind daher deutlich seltener blockiert. Laut einer Cloudflare-Analyse werden über 40 % des Web-Trajectories von Bots generiert, weshalb Anti-Bot-Systeme immer aggressiver werden.

PowerShell bietet mit Invoke-WebRequest und Invoke-RestMethod zwei mächtige Cmdlets, die nativ Proxy-Unterstützung bieten. Sie brauchen keine externen Bibliotheken — alles funktioniert mit Boardmitteln ab PowerShell 5.1, und PowerShell 7 adds even more flexibility mit ForEach-Object -Parallel.

Grundlagen: Proxy-Parameter in Invoke-WebRequest und Invoke-RestMethod

Beide Cmdlets unterstützen drei wesentliche Proxy-Parameter:

• -Proxy — die URL des Proxy-Servers (z. B. http://gate.proxyhat.com:8080)
• -ProxyCredential — ein [pscredential]-Objekt mit Benutzername und Passwort
• -ProxyUseDefaultCredentials — verwendet die Windows-Anmeldeinformationen des aktuellen Benutzers

Hier ist das einfachste Beispiel mit ProxyHat:

# ProxyHat-Zugangsdaten sicher eingeben
$cred = Get-Credential -Message 'ProxyHat Login'

# HTTP-GET über Proxy mit Invoke-WebRequest
$response = Invoke-WebRequest -Uri 'https://httpbin.org/ip' `
    -Proxy 'http://gate.proxyhat.com:8080' `
    -ProxyCredential $cred `
    -UseBasicParsing

Write-Host $response.Content

Wenn Sie die Anmeldedaten nicht interaktiv eingeben wollen, können Sie ein [pscredential] direkt aus Klartext erstellen:

# PSCredential aus Klartext erstellen (für Skripte/Cron-Jobs)
$username = 'user'
$securePassword = ConvertTo-SecureString 'pass' -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential($username, $securePassword)

# Invoke-RestMethod mit Proxy
$data = Invoke-RestMethod -Uri 'https://api.example.com/v1/data' `
    -Proxy 'http://gate.proxyhat.com:8080' `
    -ProxyCredential $cred

$data | ConvertTo-Json -Depth 5

Achtung: Das Speichern von Passwörtern im Klartext ist nur für Tests geeignet. In Produktion sollten Sie ConvertFrom-SecureString mit einem Export-Schlüssel oder SecretManagement verwenden.

Geo-Targeting und Sticky Sessions im Proxy-Benutzernamen

ProxyHat erlaubt es, Geo-Targeting und Session-Stickiness direkt im Benutzernamen zu kodieren. Das Format ist:

• user-country-US — US-IP
• user-country-DE-city-berlin — IP aus Berlin, Deutschland
• user-session-abc123 — Sticky Session mit ID abc123
• user-country-DE-session-myid — kombiniert Land und Session

Um dies in PowerShell zu nutzen, bauen wir eine Hilfsfunktion, die ein [pscredential] mit dem richtigen Benutzernamen erzeugt:

function New-ProxyHatCredential {
    param(
        [string]$BaseUser = 'user',
        [string]$Password = 'pass',
        [string]$Country,
        [string]$City,
        [string]$SessionId
    )

    $parts = @($BaseUser)
    if ($Country) { $parts += "country-$Country" }
    if ($City)   { $parts += "city-$City" }
    if ($SessionId) { $parts += "session-$SessionId" }

    $username = ($parts -join '-')
    $securePass = ConvertTo-SecureString $Password -AsPlainText -Force
    return New-Object System.Management.Automation.PSCredential($username, $securePass)
}

# US-IP mit Sticky Session
$credUS = New-ProxyHatCredential -Country 'US' -SessionId 'sess-001'

# Berliner IP
$credDE = New-ProxyHatCredential -Country 'DE' -City 'berlin'

# Anfrage über US-Proxy
$resp = Invoke-WebRequest -Uri 'https://httpbin.org/ip' `
    -Proxy 'http://gate.proxyhat.com:8080' `
    -ProxyCredential $credUS `
    -UseBasicParsing

Write-Host "US-IP: $($resp.Content)"

Feinsteuerung mit System.Net.WebProxy

Für Szenarien, in denen Sie mehr Kontrolle über den zugrundeliegenden HttpClient brauchen, können Sie ein [System.Net.WebProxy]-Objekt direkt erstellen und an ein HttpClientHandler übergeben. Das ist besonders nützlich, wenn Sie mit [System.Net.Http.HttpClient] direkt arbeiten:

Add-Type -AssemblyName System.Net.Http

# WebProxy-Objekt mit Credentials
$proxy = New-Object System.Net.WebProxy('http://gate.proxyhat.com:8080', $true)
$proxy.Credentials = New-Object System.Net.NetworkCredential('user-country-US', 'pass')

# HttpClientHandler mit Proxy
$handler = New-Object System.Net.Http.HttpClientHandler
$handler.Proxy = $proxy
$handler.UseProxy = $true

# HttpClient erstellen
$client = New-Object System.Net.Http.HttpClient($handler)
$client.Timeout = [TimeSpan]::FromSeconds(30)

# Anfrage senden
$response = $client.GetAsync('https://httpbin.org/ip').Result
$body = $response.Content.ReadAsStringAsync().Result
Write-Host $body

# Aufräumen
$client.Dispose()
$handler.Dispose()

Sessions, Cookies und Header über mehrere Aufrufe hinweg persistieren

Wenn Sie sich bei einer Website anmelden oder über mehrere Seiten navigieren, müssen Cookies und Header konsistent bleiben. PowerShell bietet dafür die Parameter -SessionVariable und -WebSession, die ein WebRequestSession-Objekt verwalten:

# Session initialisieren
$session = $null

# Erste Anfrage — Session wird in $session gespeichert
$loginPage = Invoke-WebRequest -Uri 'https://example.com/login' `
    -Proxy 'http://gate.proxyhat.com:8080' `
    -ProxyCredential (New-ProxyHatCredential -Country 'US') `
    -SessionVariable session `
    -UserAgent 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' `
    -UseBasicParsing

# Custom Header setzen
$session.Headers['Accept'] = 'application/json'
$session.Headers['X-Custom-Header'] = 'MyValue'

# Zweite Anfrage mit derselben Session
$dataPage = Invoke-WebRequest -Uri 'https://example.com/api/data' `
    -WebSession $session `
    -Proxy 'http://gate.proxyhat.com:8080' `
    -ProxyCredential (New-ProxyHatCredential -Country 'US') `
    -UseBasicParsing

Write-Host $dataPage.Content

Wichtig: Die Proxy-Credentials werden nicht automatisch in der Session gespeichert. Sie müssen -Proxy und -ProxyCredential bei jedem Aufruf erneut angeben, wenn Sie die Session verwenden.

Residential Proxys für blockierte Endpunkte: Paging-API mit Retry

Ein typischer Anwendungsfall ist das Durchblättern einer paginierten JSON-API, die Datacenter-IPs blockiert. Hier kombinieren wir Invoke-RestMethod, Session-Rotation und Retry/Backoff. Die Parameter -MaximumRetryCount und -RetryIntervalSec sind ab PowerShell 6+ verfügbar und bieten integrierte Wiederholungslogik:

function Get-PaginatedData {
    param(
        [string]$BaseUrl = 'https://api.example.com/items',
        [int]$PageSize = 100,
        [int]$MaxPages = 10,
        [int]$MaxRetries = 3,
        [int]$RetryInterval = 5
    )

    $allResults = @()
    $page = 1

    while ($page -le $MaxPages) {
        # Neue Session-ID pro Seite für IP-Rotation
        $sessionId = "page-$page-$(Get-Date -Format 'HHmmss')"
        $cred = New-ProxyHatCredential -Country 'US' -SessionId $sessionId

        $uri = "$BaseUrl`?page=$page&per_page=$PageSize"

        try {
            $response = Invoke-RestMethod -Uri $uri `
                -Proxy 'http://gate.proxyhat.com:8080' `
                -ProxyCredential $cred `
                -MaximumRetryCount $MaxRetries `
                -RetryIntervalSec $RetryInterval `
                -Headers @{ 'Accept' = 'application/json' } `
                -UserAgent 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' `
                -TimeoutSec 30

            if (-not $response.items -or $response.items.Count -eq 0) {
                Write-Host "Keine Daten mehr auf Seite $page. Abbruch."
                break
            }

            $allResults += $response.items
            Write-Host "Seite $page: $($response.items.Count) Einträge geladen."
            $page++

            # Höflichkeits-Pause: 500ms zwischen Anfragen
            Start-Sleep -Milliseconds 500
        }
        catch {
            Write-Warning "Fehler auf Seite $page: $($_.Exception.Message)"

            # Bei HTTP 429 (Too Many Requests) länger warten
            if ($_.Exception.Response.StatusCode -eq 429) {
                Write-Host "Rate limit erreicht, warte 30s..."
                Start-Sleep -Seconds 30
                continue  # gleiche Seite erneut versuchen
            }

            # Bei HTTP 403 neue Session probieren
            if ($_.Exception.Response.StatusCode -eq 403) {
                Write-Host "403 Forbidden, rotiere IP und versuche erneut..."
                Start-Sleep -Seconds 10
                continue
            }

            # Sonst: Seite überspringen
            $page++
        }
    }

    return $allResults
}

# Aufruf
$results = Get-PaginatedData -MaxPages 20
Write-Host "Insgesamt $($results.Count) Einträge gesammelt."

Dieses Muster ist für PowerShell web scraping besonders wertvoll, weil es drei Anti-Blockierungs-Strategien kombiniert: IP-Rotation über wechselnde Session-IDs, integriertes Retry mit Backoff und adaptive Wartezeiten bei Rate-Limits.

Produktionstipps: Umgebungsvariablen, TLS und Parallelität

Umgebungsvariablen für Kind-Prozesse

Wenn Ihr PowerShell-Skript externe Tools wie curl, git oder Python-Skripte aufruft, die ebenfalls den Proxy nutzen sollen, setzen Sie die Standard-Proxy-Umgebungsvariablen:

# ProxyHat-Proxy als Umgebungsvariable setzen
$env:HTTP_PROXY = 'http://user-country-US:pass@gate.proxyhat.com:8080'
$env:HTTPS_PROXY = 'http://user-country-US:pass@gate.proxyhat.com:8080'

# Jetzt funktionieren curl und andere Tools automatisch
curl.exe https://httpbin.org/ip

# Für .NET-basierte Tools auch NO_PROXY für interne Adressen
$env:NO_PROXY = 'localhost,127.0.0.1,*.internal.corp'

TLS-Konfiguration

Standardmäßig verwendet PowerShell in älteren Versionen TLS 1.0, was viele moderne APIs ablehnen. Setzen Sie explizit TLS 1.2 oder 1.3:

# TLS 1.2 und 1.3 erzwingen (vor der ersten Anfrage!)
[Net.ServicePointManager]::SecurityProtocol = `
    [Net.SecurityProtocolType]::Tls12 -bor [Net.SecurityProtocolType]::Tls13

# Ab PowerShell 7 funktioniert auch:
# [System.Net.ServicePointManager]::SecurityProtocol = ...
# oder pro Request mit -SslProtocols (nur PS Core)

Parallelität mit ForEach-Object -Parallel (PowerShell 7+)

Für Hochdurchsatz-Szenarien nutzt ForEach-Object -Parallel Runspaces. Jeder Runspace braucht seine eigene Proxy-Session:

$urls = 1..50 | ForEach-Object { "https://api.example.com/items/$_" }

$results = $urls | ForEach-Object -Parallel {
    $url = $_
    $sessionId = "par-$([System.Guid]::NewGuid().ToString('N').Substring(0,8))"
    $user = "user-country-US-session-$sessionId"
    $securePass = ConvertTo-SecureString 'pass' -AsPlainText -Force
    $cred = New-Object System.Management.Automation.PSCredential($user, $securePass)

    try {
        $resp = Invoke-RestMethod -Uri $url `
            -Proxy 'http://gate.proxyhat.com:8080' `
            -ProxyCredential $cred `
            -TimeoutSec 20 `
            -MaximumRetryCount 2 `
            -RetryIntervalSec 3
        return [PSCustomObject]@{ Url = $url; Status = 'OK'; Data = $resp }
    }
    catch {
        return [PSCustomObject]@{ Url = $url; Status = 'Error'; Error = $_.Exception.Message }
    }
} -ThrottleLimit 10

$ok = ($results | Where-Object Status -eq 'OK').Count
Write-Host "$ok von $($urls.Count) erfolgreich."

Mit -ThrottleLimit 10 senden Sie bis zu 10 Anfragen gleichzeitig. Bei 50 URLs und durchschnittlich 200 ms pro Anfrage reduziert sich die Gesamtzeit von ~10 Sekunden (sequenziell) auf ~1 Sekunde (parallel).

Ethik und Rechtliches

Web Scraping ist legal, solange Sie öffentlich zugängliche Daten abrufen und die Nutzungsbedingungen (ToS) der Ziel-Website respektieren. Im US-Recht regelt der Computer Fraud and Abuse Act (CFAA) den unbefugten Zugriff auf Computersysteme. In der EU gilt die DSGVO (GDPR), die personenbezogene Daten schützt. Beachten Sie folgende Grundsätze:

• Prüfen Sie zuerst, ob es eine offizielle API gibt. APIs sind stabiler, schneller und rechtlich sicherer als Scraping.
• Respektieren Sie robots.txt und die ToS der Ziel-Website.
• Sammeln Sie keine personenbezogenen Daten ohne Rechtsgrundlage.
• Vermeiden Sie übermäßige Last — verwenden Sie angemessene Raten und Pausen.

ProxyHat unterstützt Sie bei rechtmäßigem Scraping mit Geo-Targeting für länderspezifische Daten und flexiblen Preisplänen. Die ProxyHat-SDK teilt dieselben Endpunkte wie die direkte Proxy-Verwendung, sodass Sie nahtlos zwischen PowerShell und anderen Sprachen wechseln können.

Key Takeaways

• Invoke-WebRequest und Invoke-RestMethod unterstützen Proxys nativ über -Proxy und -ProxyCredential.
• Geo-Targeting und Sticky Sessions werden im Benutzernamen kodiert (z. B. user-country-US-session-abc123).
• -SessionVariable und -WebSession persistieren Cookies über mehrere Aufrufe.
• -MaximumRetryCount und -RetryIntervalSec bieten integriertes Retry/Backoff ab PowerShell 6+.
• Residential Proxys sind unerlässlich für Endpunkte, die Datacenter-IPs blockieren.
• Setzen Sie TLS 1.2+ mit [Net.ServicePointManager]::SecurityProtocol und nutzen Sie $env:HTTPS_PROXY für Kind-Prozesse.
• ForEach-Object -Parallel in PowerShell 7 ermöglicht bis zu 10x schnelleren Durchsatz bei gleichzeitiger IP-Rotation.

Bereit loszulegen? Besuchen Sie das ProxyHat-Dokumentationsportal für weitere Details und Web-Scraping-Anwendungsfälle oder SERP-Tracking-Szenarien.