Proxies in Kotlin verwenden: Ktor Client & OkHttp Leitfaden 2026

Wer Proxies in Kotlin verwenden möchte, trifft schnell auf eine Reihe engine-spezifischer Eigenheiten: Ktor abstrahiert den HTTP-Client hinter einem plattformneutralen API, aber Proxy-Authentifizierung wird je nach Engine (CIO, OkHttp, Darwin) unterschiedlich gehandhabt. Dieser Leitfaden zeigt, wie Sie Kotlin proxy-Funktionalität mit Ktor 3 und OkHttp produktiv einsetzen – von der Projekteinrichtung über Geo-Targeting und Sticky Sessions bis hin zu Concurrent Scraping mit Koroutinen und Produktionshärtung.

Warum Proxies in Kotlin verwenden? Technischer Kontext

Android-Apps und Kotlin-Backends greifen häufig auf öffentliche Web-APIs zu, die Datencenter-IP-Adressen blockieren oder ratenlimitieren. Cloud-Provider wie AWS, Google Cloud und Hetzner verwenden bekannte ASNs, die von Anti-Bot-Systemen wie Cloudflare, Datadome und PerimeterX schnell als Rechenzentrums-Traffic klassifiziert werden. Residential Proxies verwenden IP-Adressen echter ISPs und haben daher eine wesentlich höhere Erfolgsquote bei App- und Social-Media-Zielen.

Die Kernherausforderungen beim Einsatz von Ktor client proxy-Konfiguration:

• Proxy-Authentifizierung ist engine-spezifisch – der CIO-Engine unterstützt Proxy-Authorization nur über manuelle Header, während OkHttp einen Authenticator für 407-Challenges bereitstellt.
• Geo-Targeting muss oft im Benutzernamen kodiert werden (z. B. user-country-DE-city-berlin), nicht als separate URL-Parameter.
• SOCKS5 erfordert auf JVM-Ebene System-Properties (java.net.socks.username), da java.net.Proxy keine Authentifizierung direkt unterstützt.
• Concurrency – beim Kotlin Web Scraping müssen Sie gleichzeitige Verbindungen über einen Semaphore oder ein Connection-Limit steuern, um Rate-Limits zu respektieren.

Residential Proxies bieten typischerweise Erfolgsraten von 90–99 % bei SERP-Scraping, verglichen mit 20–50 % bei Datacenter-IPs, die von Anti-Bot-Systemen erkannt werden. Latenz liegt bei 200–800 ms pro Anfrage – langsamer als Datacenter, aber dafür deutlich zuverlässiger.

Projekteinrichtung: Ktor 3 mit CIO- und OkHttp-Engine

Gradle-Abhängigkeiten (Kotlin DSL)

Für ein Kotlin Multiplatform- oder JVM-Projekt benötigen Sie den Ktor-Client mit mindestens zwei Engines: CIO (pure Kotlin, plattformübergreifend) und OkHttp (JVM-spezifisch, bietet feingranulare Proxy-Kontrolle).

// build.gradle.kts
val ktorVersion = "3.0.3"
val okhttpVersion = "4.12.0"

dependencies {
    // Ktor Client Core
    implementation("io.ktor:ktor-client-core:$ktorVersion")
    // CIO Engine (pure Kotlin, koroutinenbasiert)
    implementation("io.ktor:ktor-client-cio:$ktorVersion")
    // OkHttp Engine (JVM, volle Proxy-Auth-Unterstützung)
    implementation("io.ktor:ktor-client-okhttp:$ktorVersion")
    // Content Negotiation für JSON-Antworten
    implementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
    // Logging
    implementation("io.ktor:ktor-client-logging:$ktorVersion")
    // OkHttp direkt (für Raw-Client-Baseline)
    implementation("com.squareup.okhttp3:okhttp:$okhttpVersion")
    // Koroutinen
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
}

Raw OkHttp-Baseline mit java.net.Proxy

Bevor wir Ktor konfigurieren, hier die direkte OkHttp-Variante mit OkHttpClient.Builder().proxy(). Dies ist die Grundlage, auf der die Ktor OkHttp-Engine intern aufbaut.

import okhttp3.OkHttpClient
import okhttp3.Request
import java.net.InetSocketAddress
import java.net.Proxy
import java.net.URI
import java.util.Base64
import java.util.concurrent.TimeUnit

fun createOkHttpWithProxy(
    proxyHost: String,
    proxyPort: Int,
    username: String,
    password: String
): OkHttpClient {
    // Basic-Auth-Header für Proxy-Authentifizierung vorab generieren
    val auth = "$username:$password"
    val encodedAuth = Base64.getEncoder().encodeToString(auth.toByteArray())
    val proxyAuthHeader = "Basic $encodedAuth"

    val proxyAddr = InetSocketAddress(proxyHost, proxyPort)

    return OkHttpClient.Builder()
        .proxy(Proxy(Proxy.Type.HTTP, proxyAddr))
        // Proxy-Authorization als Header hinzufügen (OkHttp-spezifisch)
        .proxyAuthenticator { _, response ->
            response.request.newBuilder()
                .header("Proxy-Authorization", proxyAuthHeader)
                .build()
        }
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(15, TimeUnit.SECONDS)
        .retryOnConnectionFailure(true)
        .build()
}

fun main() {
    // ProxyHat HTTP-Gateway
    val client = createOkHttpWithProxy(
        proxyHost = "gate.proxyhat.com",
        proxyPort = 8080,
        username = "user-country-DE-city-berlin",
        password = "IhrPasswort"
    )

    val request = Request.Builder()
        .url("https://httpbin.org/ip")
        .build()

    client.newCall(request).execute().use { response ->
        println("Status: ${response.code}")
        println(response.body?.string())
    }
}

Ktor Client mit Proxy-Konfiguration

HTTP-Proxy über die OkHttp-Engine

Die Ktor OkHttp-Engine delegiert an OkHttpClient.Builder, sodass Sie die gleiche Proxy-Konfiguration verwenden können. Der Schlüssel: Proxy-Authentifizierung wird über defaultRequest mit einem Proxy-Authorization-Header hinzugefügt, da der CIO-Engine dies nicht automatisch macht.

import io.ktor.client.*
import io.ktor.client.engine.okhttp.*
import io.ktor.client.plugins.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json
import java.net.InetSocketAddress
import java.net.Proxy
import java.util.Base64
import java.util.concurrent.TimeUnit

fun createKtorClientWithProxy(
    username: String,
    password: String,
    stickySession: String? = null,
    country: String = "DE",
    city: String? = null
): HttpClient {
    // Geo-Targeting und Sticky Session im Benutzernamen kodieren
    val fullUsername = buildString {
        append("user")
        append("-country-").append(country)
        if (city != null) append("-city-").append(city)
        if (stickySession != null) append("-session-").append(stickySession)
    }

    val auth = "$fullUsername:$password"
    val encodedAuth = Base64.getEncoder().encodeToString(auth.toByteArray())
    val proxyAuthHeader = "Basic $encodedAuth"

    return HttpClient(OkHttp) {
        engine {
            // OkHttp-spezifische Proxy-Konfiguration
            config {
                proxy(Proxy(Proxy.Type.HTTP, InetSocketAddress("gate.proxyhat.com", 8080)))
                // Authenticator für 407 Proxy-Auth-Challenges
                proxyAuthenticator { _, response ->
                    response.request.newBuilder()
                        .header("Proxy-Authorization", proxyAuthHeader)
                        .build()
                }
                connectTimeout(10, TimeUnit.SECONDS)
                readTimeout(30, TimeUnit.SECONDS)
                // Connection Pool für Wiederverwendung
                connectionPool(
                    okhttp3.ConnectionPool(
                        maxIdleConnections = 20,
                        keepAliveDuration = 5,
                        TimeUnit.MINUTES
                    )
                )
            }
        }

        install(ContentNegotiation) {
            json(Json { ignoreUnknownKeys = true })
        }

        install(HttpTimeout) {
            requestTimeoutMillis = 30000
            connectTimeoutMillis = 10000
            socketTimeoutMillis = 30000
        }

        install(HttpRequestRetry) {
            maxRetries = 3
            retryIf { request, response ->
                response.status.value in listOf(429, 500, 502, 503)
            }
            retryOnExceptionIf { _, cause ->
                cause is java.net.SocketTimeoutException
            }
            exponentialDelay()
        }

        // Proxy-Authorization in jedem Request-Header setzen
        defaultRequest {
            header("Proxy-Authorization", proxyAuthHeader)
            header(HttpHeaders.UserAgent, "Mozilla/5.0 (compatible; MyBot/1.0)")
        }
    }
}

suspend fun fetchWithProxy() {
    val client = createKtorClientWithProxy(
        username = "user",
        password = "IhrPasswort",
        country = "DE",
        city = "berlin",
        stickySession = "abc123"
    )

    client.use { c ->
        val response: HttpResponse = c.get("https://httpbin.org/ip")
        println("Status: ${response.status}")
        println(response.bodyAsText())
    }
}

Hinweis: Der Proxy-Authorization-Header in defaultRequest ist bei der CIO-Engine zwingend erforderlich, da CIO keine native Proxy-Authentifizierung unterstützt. Bei der OkHttp-Engine übernimmt der proxyAuthenticator die 407-Challenge, aber der Header in defaultRequest verhindert den ersten Roundtrip.

SOCKS5-Proxy über Port 1080

SOCKS5 ist die bevorzugte Wahl, wenn HTTP-Header-Manipulation durch Zwischenproxys ein Problem darstellt. Auf der JVM wird SOCKS5-Authentifizierung über System-Properties konfiguriert, da java.net.Proxy keine Credentials direkt akzeptiert. Die offizielle Java-Dokumentation beschreibt diese Properties im Detail.

import io.ktor.client.*
import io.ktor.client.engine.okhttp.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import java.net.InetSocketAddress
import java.net.Proxy

fun configureSocks5SystemProperties(username: String, password: String) {
    // SOCKS5-Authentifizierung über JVM-System-Properties
    System.setProperty("socksProxyHost", "gate.proxyhat.com")
    System.setProperty("socksProxyPort", "1080")
    System.setProperty("java.net.socks.username", username)
    System.setProperty("java.net.socks.password", password)
}

suspend fun fetchViaSocks5() {
    // Username mit Geo-Targeting
    val username = "user-country-US-session-mySession42"
    val password = "IhrPasswort"

    configureSocks5SystemProperties(username, password)

    val client = HttpClient(OkHttp) {
        engine {
            config {
                // SOCKS-Proxy explizit setzen
                proxy(Proxy(Proxy.Type.SOCKS, InetSocketAddress("gate.proxyhat.com", 1080)))
            }
        }
    }

    client.use { c ->
        val response = c.get("https://httpbin.org/ip")
        println(response.bodyAsText())
    }
}

Residential Proxies für App- und Social-Media-Ziele

Warum sind Residential Proxies bei Kotlin Web Scraping so wichtig? App-APIs (Instagram, TikTok, Amazon) und SERP-Endpunkte verwenden ASN-basierte Filterung. Eine Anfrage von einer AWS-IP (54.x.x.x) wird sofort als Bot erkannt, während eine Anfrage von einer Vodafone-DSL-IP (188.x.x.x) als normaler Nutzer-Traffic durchgeht.

Konkurrenter Fan-Out mit Koroutinen und Semaphore

Das folgende Beispiel zeigt, wie Sie mehrere URLs gleichzeitig über verschiedene Proxy-Sessions abrufen, mit einem Semaphore zur Ratenbegrenzung. Dies ist das Kernmuster für produktives Kotlin Web Scraping.

import io.ktor.client.*
import io.ktor.client.engine.okhttp.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import java.net.InetSocketAddress
import java.net.Proxy
import java.util.Base64
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger

// --- Hilfsfunktion: Ktor-Client pro Session ---
fun createProxyClient(sessionId: String, country: String): HttpClient {
    val username = "user-country-$country-session-$sessionId"
    val password = "IhrPasswort"
    val encodedAuth = Base64.getEncoder()
        .encodeToString("$username:$password".toByteArray())

    return HttpClient(OkHttp) {
        engine {
            config {
                proxy(Proxy(Proxy.Type.HTTP,
                    InetSocketAddress("gate.proxyhat.com", 8080)))
                proxyAuthenticator { _, response ->
                    response.request.newBuilder()
                        .header("Proxy-Authorization", "Basic $encodedAuth")
                        .build()
                }
                connectTimeout(10, TimeUnit.SECONDS)
                readTimeout(30, TimeUnit.SECONDS)
            }
        }
        install(io.ktor.client.plugins.HttpTimeout) {
            requestTimeoutMillis = 30000
        }
    }
}

// --- Concurrent Fan-Out ---
suspend fun scrapeUrls(urls: List<String>, maxConcurrency: Int = 10) {
    val semaphore = Semaphore(maxConcurrency)
    val successCount = AtomicInteger(0)
    val failCount = AtomicInteger(0)

    coroutineScope {
        urls.mapIndexed { index, url ->
            async(Dispatchers.IO) {
                semaphore.withPermit {
                    // Jede Anfrage bekommt eine eigene Sticky Session
                    val sessionId = "sess-${index.toString().padStart(4, '0')}"
                    val client = createProxyClient(sessionId, "DE")

                    try {
                        client.use { c ->
                            val response = c.get(url)
                            if (response.status.value in 200..299) {
                                successCount.incrementAndGet()
                                println("[OK] $url -> ${response.status}")
                            } else {
                                failCount.incrementAndGet()
                                println("[FAIL] $url -> ${response.status}")
                            }
                        }
                    } catch (e: Exception) {
                        failCount.incrementAndGet()
                        println("[ERROR] $url -> ${e.message}")
                    }
                }
            }
        }.awaitAll()
    }

    println("\nErgebnis: ${successCount.get()} erfolgreich, " +
            "${failCount.get()} fehlgeschlagen")
}

fun main() = runBlocking {
    val urls = (1..50).map { i ->
        "https://httpbin.org/delay/${i % 3 + 1}"
    }
    scrapeUrls(urls, maxConcurrency = 10)
}

In der Praxis sollten Sie 5–20 gleichzeitige Verbindungen pro Proxy-Session verwenden. Bei 100 gleichzeitigen Sessions mit je 10 Verbindungen erreichen Sie bis zu 1000 Requests/Sekunde – aber nur, wenn der Zielserver dies zulässt. Überprüfen Sie immer die robots.txt und die Nutzungsbedingungen des Ziels.

Proxy-Typen im Vergleich

Weitere Informationen zu verfügbaren Standorten finden Sie auf unserer Proxy-Standortseite. Für Preisauskünfte vergleichen Sie unsere Preisseite.

Produktionshärtung: OkHttp Authenticator, Timeouts & TLS

407-Challenge-Behandlung mit OkHttp Authenticator

Wenn der Proxy einen 407 Proxy Authentication Required zurückgibt, muss der Client antworten. Der OkHttp Authenticator fängt dies ab und fügt den Header automatisch hinzu. Dies ist robuster als das Setzen in defaultRequest, da es auch nach Connection-Pool-Wiederverwendung funktioniert.

import okhttp3.Authenticator
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.Route
import java.net.InetSocketAddress
import java.net.Proxy
import java.util.Base64
import java.util.concurrent.TimeUnit
import javax.net.ssl.SSLContext
import javax.net.ssl.TrustManagerFactory
import javax.net.ssl.X509TrustManager
import java.security.KeyStore

fun createHardenedOkHttp(
    proxyHost: String = "gate.proxyhat.com",
    proxyPort: Int = 8080,
    username: String,
    password: String
): OkHttpClient {
    val encodedAuth = Base64.getEncoder()
        .encodeToString("$username:$password".toByteArray())

    // Custom Trust-Manager mit System-Trust-Store als Basis
    val tmf = TrustManagerFactory.getInstance(
        TrustManagerFactory.getDefaultAlgorithm()
    )
    tmf.init(null as KeyStore?)
    val trustManagers = tmf.trustManagers
    val x509tm = trustManagers.filterIsInstance<X509TrustManager>().first()

    val sslContext = SSLContext.getInstance("TLS")
    sslContext.init(null, arrayOf(x509tm), java.security.SecureRandom())

    // Proxy-Authenticator: reagiert auf 407-Challenges
    val proxyAuth = Authenticator { _: Route?, response: Response ->
        // Verhindere Endlosschleife bei falschen Credentials
        if (response.request.header("Proxy-Authorization") != null) {
            return@Authenticator null // Auth fehlgeschlagen, abbrechen
        }
        response.request.newBuilder()
            .header("Proxy-Authorization", "Basic $encodedAuth")
            .build()
    }

    return OkHttpClient.Builder()
        .proxy(Proxy(Proxy.Type.HTTP, InetSocketAddress(proxyHost, proxyPort)))
        .proxyAuthenticator(proxyAuth)
        .sslSocketFactory(sslContext.socketFactory, x509tm)
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(15, TimeUnit.SECONDS)
        .retryOnConnectionFailure(true)
        .connectionPool(
            okhttp3.ConnectionPool(
                maxIdleConnections = 20,
                keepAliveDuration = 5,
                TimeUnit.MINUTES
            )
        )
        .build()
}

// Verwendung mit Retry-Logik (Circuit-Breaker-Pattern)
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit

class ProxyRequestExecutor(
    private val client: OkHttpClient,
    private val maxRetries: Int = 3,
    maxConcurrency: Int = 10
) {
    private val semaphore = Semaphore(maxConcurrency)
    private var consecutiveFailures = 0
    private var circuitOpen = false
    private var circuitOpenTime = 0L

    suspend fun executeWithRetry(url: String): String? = semaphore.withPermit {
        var attempt = 0
        while (attempt < maxRetries) {
            // Circuit Breaker prüfen
            if (circuitOpen) {
                val elapsed = System.currentTimeMillis() - circuitOpenTime
                if (elapsed < 30_000) {
                    delay(1000)
                    return@withPermit null
                }
                circuitOpen = false
                consecutiveFailures = 0
            }

            try {
                val request = Request.Builder().url(url).build()
                val response = withContext(Dispatchers.IO) {
                    client.newCall(request).execute()
                }

                response.use { r ->
                    if (r.code in 200..299) {
                        consecutiveFailures = 0
                        return@withPermit r.body?.string()
                    } else if (r.code == 429) {
                        // Rate limit: exponentielles Backoff
                        val delay = (1000L shl attempt).coerceAtMost(16000L)
                        delay(delay)
                        attempt++
                    } else if (r.code in 500..599) {
                        delay(500L * (attempt + 1))
                        attempt++
                    } else {
                        return@withPermit null // Nicht wiederholbarer Fehler
                    }
                }
            } catch (e: java.net.SocketTimeoutException) {
                consecutiveFailures++
                if (consecutiveFailures > 5) {
                    circuitOpen = true
                    circuitOpenTime = System.currentTimeMillis()
                }
                delay(1000L * (attempt + 1))
                attempt++
            } catch (e: Exception) {
                println("Fehler bei Versuch ${attempt + 1}: ${e.message}")
                attempt++
            }
        }
        null
    }
}

Android NetworkSecurityConfig

Auf Android-Geräten mit API-Level 24+ (Android 7.0+) wird Klartext-HTTP standardmäßig blockiert. Wenn Ihr Proxy-Gateway HTTP verwendet (was bei gate.proxyhat.com:8080 der Fall ist), müssen Sie eine network_security_config.xml erstellen. Die Android-Dokumentation beschreibt das Format.

<!-- res/xml/network_security_config.xml -->
<network-security-config>
    <!-- Proxy-Gateway als Klartext-Exception -->
    <domain-config cleartextTrafficPermitted="true">
        <domain includeSubdomains="true">gate.proxyhat.com</domain>
    </domain-config>
    <!-- HTTPS-Ziele: System-Trust-Store + eigene CA -->
    <base-config>
        <trust-anchors>
            <certificates src="system"/>
            <certificates src="user"/>
        </trust-anchors>
    </base-config>
</network-security-config>

Danach in der AndroidManifest.xml referenzieren:

<application
    android:networkSecurityConfig="@xml/network_security_config"
    ...>
    ...
</application>

Ethisches Scraping und rechtliche Aspekte

Beim Kotlin Web Scraping sollten Sie folgende Grundsätze beachten:

• Nur öffentliche Daten abrufen – Inhalte hinter Login-Schranken sind oft urheberrechtlich geschützt oder vertraglich eingeschränkt.
• robots.txt respektieren – sie ist eine maschinenlesbare Erklärung des Seitenbetreibers, welche Bereiche nicht gecrawlt werden sollen.
• CFAA in den USA – der Computer Fraud and Abuse Act kann bei unbefugtem Zugriff greifen. Der Wikipedia-Artikel zum CFAA bietet einen Überblick.
• DSGVO/GDPR in der EU – personenbezogene Daten dürfen nur mit Rechtsgrundlage verarbeitet werden. Bei reinen SERP-Daten ohne Personenbezug ist dies meist unproblematisch, aber bei Social-Media-Profilen ist Vorsicht geboten.
• Bevorzugung offizieller APIs – wenn eine Plattform eine API anbietet, verwenden Sie diese zuerst. Proxies sind eine Ergänzung, kein Ersatz.

ProxyHat unterstützt sowohl Web-Scraping als auch SERP-Tracking mit residential, mobile und datacenter Proxies. Die vollständige technische Dokumentation finden Sie unter docs.proxyhat.com.

ProxyHat SDK: Dasselbe Muster, weniger Boilerplate

Das ProxyHat SDK spiegelt genau das oben gezeigte Muster wider – es kapselt den Proxy-Authorization-Header, die Geo-Targeting-Parameter und die Sticky-Session-Logik in einer einzigen Builder-API. Anstatt den Base64-Header manuell zu generieren, übergeben Sie Country, City und Session-ID als Parameter:

// ProxyHat SDK (vereinfacht – gleiche Verbindungsdetails)
// HTTP: gate.proxyhat.com:8080
// SOCKS5: gate.proxyhat.com:1080

// Manuelle Konfiguration entspricht dem SDK-Muster:
// Username-Format: user-country-{COUNTRY}-city-{CITY}-session-{SESSION_ID}
// Password: Ihr ProxyHat-Passwort

// Beispiel mit curl (Terminal-Test):
// curl -x http://user-country-DE-city-berlin-session-abc123:IhrPasswort@gate.proxyhat.com:8080 https://httpbin.org/ip

// In Kotlin entspricht dies genau dem oben gezeigten createKtorClientWithProxy()

Key Takeaways

• Proxy-Auth ist engine-spezifisch: CIO benötigt manuelle Proxy-Authorization-Header, OkHttp bietet einen Authenticator für 407-Challenges.
• Geo-Targeting im Username: user-country-DE-city-berlin-session-abc123 kodiert Land, Stadt und Sticky Session in einem String.
• SOCKS5 über System-Properties: java.net.socks.username und java.net.socks.password sind auf JVM-Ebene erforderlich.
• Concurrency mit Semaphore: Begrenzen Sie gleichzeitige Verbindungen auf 10–20 pro Session, um Rate-Limits zu respektieren.
• Residential > Datacenter für App- und Social-Ziele: 90–99 % Erfolgsrate vs. 20–50 %.
• Produktionshärtung: Connection Pooling, exponentielles Backoff, Circuit Breaker und TLS-Konfiguration sind obligatorisch.
• Ethisch scrapen: Nur öffentliche Daten, robots.txt respektieren, offizielle APIs bevorzugen.

FAQ

Was bedeutet „Proxies in Kotlin verwenden"?

Es bezeichnet die Konfiguration von HTTP- oder SOCKS5-Proxys in Kotlin-Anwendungen – typischerweise mit Ktor Client oder OkHttp –, um Requests über eine zwischengeschaltete IP-Adresse weiterzuleiten. Dies wird für Web Scraping, Geo-Targeting, Rate-Limit-Umgehung und Anonymisierung eingesetzt. Die Proxy-Authentifizierung erfolgt meist über Basic-Auth im Proxy-Authorization-Header.

Warum ist die Proxy-Nutzung in Kotlin wichtig für Proxy-Anwender?

Kotlin-Entwickler, die Web-Scraping oder automatisierte API-Anfragen durchführen, benötigen Proxies, um IP-basierte Sperren und Rate-Limits zu umgehen. Ohne Proxies werden Datacenter-IPs von Anti-Bot-Systemen schnell erkannt. Residential Proxies bieten höhere Erfolgsraten (90–99 %), da sie echte ISP-IPs verwenden. Die Ktor-OkHttp-Engine ermöglicht feingranulare Kontrolle über Authentifizierung, Timeouts und Connection Pooling.

Welcher Proxy-Typ eignet sich am besten für die Nutzung in Kotlin?

Für Web Scraping und SERP-Tracking sind Residential Proxies die beste Wahl, da sie eine hohe Erfolgsrate (90–99 %) bei moderater Latenz (200–800 ms) bieten. Mobile Proxies sind noch zuverlässiger bei Social-Media-Zielen, aber teurer. Datacenter Proxies sind schnell und günstig, aber von Anti-Bot-Systemen leicht erkennbar (20–50 % Erfolgsrate). Die Wahl hängt vom Ziel-Domain und Budget ab.

Wie vermeidet man Sperren bei der Proxy-Nutzung in Kotlin?

Verwenden Sie Sticky Sessions, um IP-Wechsel zu kontrollieren, begrenzen Sie die Concurrency mit einem Semaphore (10–20 gleichzeitige Verbindungen), implementieren Sie exponentielles Backoff bei 429-Antworten, rotieren Sie User-Agent-Header, und respektieren Sie robots.txt. Ein Circuit Breaker verhindert Kaskadenausfälle. Bei wiederkehrenden Sperren wechseln Sie zu Residential Proxies mit Geo-Targeting passend zur Zielregion.

Kann ich SOCKS5-Proxys in Kotlin verwenden?

Ja. Auf der JVM konfigurieren Sie SOCKS5 über die System-Properties socksProxyHost, socksProxyPort, java.net.socks.username und java.net.socks.password. In OkHttp setzen Sie zusätzlich Proxy(Proxy.Type.SOCKS, InetSocketAddress(...)). ProxyHat unterstützt SOCKS5 auf Port 1080. Beachten Sie, dass java.net.Proxy keine direkte Authentifizierung akzeptiert – diese muss über System-Properties erfolgen.