Utiliser un proxy en Swift avec URLSession : guide développeur iOS et macOS

Pourquoi utiliser un proxy en Swift avec URLSession

Si vous développez une application iOS ou macOS qui doit accéder à des données web — scraping de prix, suivi SERP, recherche de contenu régional — vous rencontrerez tôt ou tard des blocages d'IP, des erreurs 403 ou des challenges CAPTCHA. Utiliser un proxy en Swift avec URLSession est la solution la plus native pour acheminer vos requêtes HTTP/HTTPS via une IP différente, sans dépendance externe.

Le problème est que URLSession ne propose pas d'API haute niveau pour les proxies. Il faut configurer manuellement un dictionnaire connectionProxyDictionary sur URLSessionConfiguration, gérer l'authentification proxy (le support des identifiants dans le dictionnaire est peu fiable), et jongler entre HTTP, HTTPS et SOCKS5. Ce guide couvre tout cela avec du code prêt à l'emploi.

Contexte technique : pourquoi les proxies résidentiels sont nécessaires

De nombreuses API et sites web bloquent les plages d'IP datacenter connues. Cloudflare, Akamai et Imperva maintiennent des listes d'IPs d'hébergeurs (AWS, OVH, DigitalOcean) et appliquent un score de réputation. Une requête depuis une IP datacenter peut recevoir un défi JavaScript ou un 403 immédiat, tandis qu'une IP résidentielle — attribuée par un FAI à un particulier — passe inaperçue.

Pour le contenu régionalement verrouillé (catalogues Netflix, prix localisés, résultats de recherche géo-ciblés), l'IP de sortie détermine ce que vous obtenez. Un proxy résidentiel au Japon renverra le contenu japonais ; un proxy aux États-Unis renverra la version américaine. C'est essentiel pour le suivi SERP et le web scraping à grande échelle.

Selon la documentation Apple, URLSessionConfiguration permet de personnaliser le comportement de la session, y compris la configuration proxy via connectionProxyDictionary. Pour plus de contexte sur les en-têtes de proxy, consultez la documentation MDN sur Proxy-Authorization.

Configurer un proxy HTTP/HTTPS dans URLSession

La méthode principale consiste à créer une URLSessionConfiguration avec un dictionnaire proxy utilisant les clés kCFNetworkProxies*. Pour un proxy HTTP pointant vers gate.proxyhat.com:8080 :

import Foundation
import CFNetwork

func makeProxySessionConfig(username: String, password: String) -> URLSessionConfiguration {
    let config = URLSessionConfiguration.default
   
    // Chaîne d'authentification Basic encodée en base64
    let credentials = "\(username):\(password)"
    let base64 = Data(credentials.utf8).base64EncodedString()
    let proxyAuth = "Basic \(base64)"
    
    // Stocker l'en-tête Proxy-Authorization pour l'utiliser dans les requêtes
    config.httpAdditionalHeaders = [
        "Proxy-Authorization": proxyAuth
    ]
    
    config.connectionProxyDictionary = [
        kCFNetworkProxiesHTTPEnable as String: 1,
        kCFNetworkProxiesHTTPProxy as String: "gate.proxyhat.com",
        kCFNetworkProxiesHTTPPort as String: 8080,
        kCFNetworkProxiesHTTPSEnable as String: 1,
        kCFNetworkProxiesHTTPSProxy as String: "gate.proxyhat.com",
        kCFNetworkProxiesHTTPSPort as String: 8080
    ]
    
    return config
}

Note importante : les clés kCFProxyUsernameKey et kCFProxyPasswordKey existent dans CFNetwork mais ne sont pas fiables avec URLSession sur iOS et macOS. Elles sont souvent ignorées. La solution recommandée est d'injecter l'en-tête Proxy-Authorization: Basic ... via httpAdditionalHeaders ou de gérer le challenge 407 via un délégué.

Gérer le challenge 407 avec URLSessionDelegate

Si l'en-tête Proxy-Authorization dans httpAdditionalHeaders ne suffit pas (notamment pour les requêtes HTTPS via CONNECT), implémentez la méthode urlSession(_:didReceive:completionHandler:) pour répondre au challenge d'authentification proxy :

final class ProxyAuthDelegate: NSObject, URLSessionDelegate {
    let proxyUsername: String
    let proxyPassword: String
    
    init(username: String, password: String) {
        self.proxyUsername = username
        self.proxyPassword = password
    }
    
    func urlSession(
        _ session: URLSession,
        didReceive challenge: URLAuthenticationChallenge,
        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
    ) {
        // Distinguer le challenge proxy (407) du challenge serveur (401)
        if challenge.protectionSpace.authenticationMethod
            == NSURLAuthenticationMethodHTTPProxy ||
           challenge.protectionSpace.authenticationMethod
            == NSURLAuthenticationMethodHTTPSProxy {
            let credential = URLCredential(
                user: proxyUsername,
                password: proxyPassword,
                persistence: .forSession
            )
            completionHandler(.useCredential, credential)
        } else {
            // Laisser le système gérer les autres challenges (TLS, etc.)
            completionHandler(.performDefaultHandling, nil)
        }
    }
}

Utilisation combinée :

let username = "user-country-US-city-newyork-session-abc123"
let password = "votre_mot_de_passe"

let config = makeProxySessionConfig(username: username, password: password)
let delegate = ProxyAuthDelegate(username: username, password: password)
let session = URLSession(configuration: config, delegate: delegate, delegateQueue: nil)

let url = URL(string: "https://httpbin.org/ip")!
let task = session.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Erreur: \(error)")
        return
    }
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}
task.resume()

Authentification et géo-ciblage avec ProxyHat

ProxyHat encode le pays, la ville et l'identifiant de session directement dans le nom d'utilisateur. Par exemple :

• user-country-US — IP résidentielle aux États-Unis
• user-country-DE-city-berlin — IP à Berlin, Allemagne
• user-country-US-city-newyork-session-abc123 — session persistante (sticky) à New York

Le paramètre session-abc123 garantit que toutes les requêtes d'une même session utilisent la même IP de sortie. Sans session, ProxyHat tourne l'IP à chaque requête — idéal pour le scraping à haut volume. Consultez la liste complète des emplacements disponibles.

SOCKS5 via les clés kCFStreamPropertySOCKSProxy

Pour le SOCKS5 sur le port 1080, URLSessionConfiguration.connectionProxyDictionary accepte les clés kCFStreamPropertySOCKSProxy* :

func makeSOCKS5SessionConfig(username: String, password: String) -> URLSessionConfiguration {
    let config = URLSessionConfiguration.default
    
    config.connectionProxyDictionary = [
        kCFNetworkProxiesSOCKSEnable as String: 1,
        kCFNetworkProxiesSOCKSProxy as String: "gate.proxyhat.com",
        kCFNetworkProxiesSOCKSPort as String: 1080,
        kCFNetworkProxiesSOCKSVersion as String: kCFStreamSocketSOCKSVersion5 as String,
        kCFNetworkProxiesSOCKSUser as String: username,
        kCFNetworkProxiesSOCKSPassword as String: password
    ]
    
    return config
}

// Utilisation
let socksConfig = makeSOCKS5SessionConfig(
    username: "user-country-FR-session-mySession01",
    password: "votre_mot_de_passe"
)
let socksSession = URLSession(configuration: socksConfig)

// Test rapide
let url = URL(string: "https://httpbin.org/ip")!
socksSession.dataTask(with: url) { data, _, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}.resume()

SOCKS5 est utile quand le trafic n'est pas du HTTP standard (WebSockets, protocoles personnalisés) ou quand vous voulez un tunnel au niveau TCP sans interception du trafic TLS.

Exemple async/await avec Codable et TaskGroup

Voici un exemple complet de scraping concurrent avec async/await, décodage Codable et TaskGroup pour paralléliser les requêtes via différentes IPs résidentielles :

import Foundation

struct IPResponse: Codable {
    let origin: String
}

struct ScrapeResult: Codable {
    let url: String
    let status: Int
    let body: String
}

actor ScrapeLogger {
    var results: [ScrapeResult] = []
    func append(_ r: ScrapeResult) { results.append(r) }
    func getAll() -> [ScrapeResult] { results }
}

func fetchViaProxy(url: URL, country: String, session: String) async throws -> ScrapeResult {
    let username = "user-country-\(country)-session-\(session)"
    let password = "votre_mot_de_passe"
    
    let credentials = "\(username):\(password)"
    let base64 = Data(credentials.utf8).base64EncodedString()
    
    let config = URLSessionConfiguration.default
    config.httpAdditionalHeaders = ["Proxy-Authorization": "Basic \(base64)"]
    config.connectionProxyDictionary = [
        kCFNetworkProxiesHTTPEnable as String: 1,
        kCFNetworkProxiesHTTPProxy as String: "gate.proxyhat.com",
        kCFNetworkProxiesHTTPPort as String: 8080,
        kCFNetworkProxiesHTTPSEnable as String: 1,
        kCFNetworkProxiesHTTPSProxy as String: "gate.proxyhat.com",
        kCFNetworkProxiesHTTPSPort as String: 8080
    ]
    config.timeoutIntervalForRequest = 30
    config.timeoutIntervalForResource = 60
    
    let urlSession = URLSession(configuration: config)
    
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.setValue("Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X)",
                     forHTTPHeaderField: "User-Agent")
    
    let (data, response) = try await urlSession.data(for: request)
    let httpResp = response as! HTTPURLResponse
    let body = String(data: data, encoding: .utf8) ?? ""
    
    return ScrapeResult(url: url.absoluteString, status: httpResp.statusCode, body: body)
}

let urls: [URL] = [
    URL(string: "https://httpbin.org/ip")!,
    URL(string: "https://httpbin.org/headers")!,
    URL(string, "https://httpbin.org/user-agent")!,
    URL(string, "https://httpbin.org/anything")!
].compactMap { $0 }

let countries = ["US", "DE", "FR", "JP", "GB"]
let logger = ScrapeLogger()

await withTaskGroup(of: Void.self) { group in
    for (index, url) in urls.enumerated() {
        let country = countries[index % countries.count]
        let session = "task-\(UUID().uuidString.prefix(8))"
        group.addTask {
            do {
                let result = try await fetchViaProxy(url: url, country: country, session: String(session))
                await logger.append(result)
            } catch {
                print("Échec pour \(url): \(error)")
            }
        }
    }
}

let allResults = await logger.getAll()
for r in allResults {
    print("[\(r.status)] \(r.url) — \(r.body.prefix(200))")
}

Ce pattern permet de répartir les requêtes sur plusieurs pays avec des sessions distinctes, réduisant le risque de blocage par IP unique. La limite pratique de concurrence sur iOS est d'environ 100 sessions simultanées par application ; au-delà, le système peut limiter les connexions réseau.

Comparaison : résidentiel vs datacenter vs mobile

Pour la plupart des cas de scraping web en Swift, les proxies résidentiels offrent le meilleur compromis fiabilité/coût. Les proxies mobiles sont supérieurs pour les plateformes sociales très protégées (Instagram, TikTok), mais plus coûteux.

Conseils de production : TLS, retry, ATS et confidentialité

Gestion TLS avec URLSessionDelegate

Pour les certificats auto-signés en environnement de test ou pour la validation personnalisée, implémentez urlSession(_:didReceive:completionHandler:) côté serveur :

final class TLSPinningDelegate: NSObject, URLSessionDelegate {
    func urlSession(
        _ session: URLSession,
        didReceive challenge: URLAuthenticationChallenge,
        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
    ) {
        if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
            // En production : valider la chaîne de certificats
            // En test : accepter temporairement
            if let trust = challenge.protectionSpace.serverTrust {
                completionHandler(.useCredential, URLCredential(trust: trust))
            } else {
                completionHandler(.cancelAuthenticationChallenge, nil)
            }
        } else {
            completionHandler(.performDefaultHandling, nil)
        }
    }
}

Attention : ne désactivez jamais la validation TLS en production. L'exemple ci-dessus est à adapter avec un pinning de certificat réel.

Retry avec backoff exponentiel

func fetchWithRetry(url: URL, maxRetries: Int = 3) async throws -> Data {
    var attempt = 0
    while attempt < maxRetries {
        do {
            let (data, _) = try await URLSession.shared.data(from: url)
            return data
        } catch {
            attempt += 1
            let delay = pow(2.0, Double(attempt)) // 2s, 4s, 8s
            try await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
            if attempt == maxRetries {
                throw error
            }
        }
    }
    fatalError("Inatteignable")
}

App Transport Security (ATS)

Apple impose ATS par défaut : seules les connexions TLS 1.2+ avec des certificats valides sont autorisées. Un proxy HTTPS comme gate.proxyhat.com:8080 fonctionne via CONNECT sans affecter ATS, car le tunnel TLS reste de bout en bout entre votre app et le serveur cible. N'ajoutez NSAllowsArbitraryLoads dans Info.plist que si vous avez une raison valable — Apple peut rejeter votre app lors de la revue App Store.

Confidentialité sur l'appareil

• Ne stockez jamais les identifiants proxy en clair dans le code source. Utilisez Keychain ou un gestionnaire de secrets sécurisé.
• Ajoutez une Privacy Policy claire si votre app collecte des données via proxy.
• Respectez les App Tracking Transparency (ATT) si votre scraping implique des données utilisateur.

Éthique et conformité légale

Le scraping de données publiques est légal dans de nombreux contextes, mais il comporte des risques :

• États-Unis : le Computer Fraud and Abuse Act (CFAA) criminalise l'accès non autorisé à des systèmes informatiques. Après l'arrêt Van Buren v. United States (2021), la portée du CFAA a été réduite pour l'accès à des données publiquement visibles, mais prudence reste de mise.
• Union européenne : le RGPD encorde le traitement des données personnelles. Le scraping de données personnelles sans base légale peut entraîner des amendes jusqu'à 4% du chiffre d'affaires annuel ou 20 millions d'euros.
• App Store Review Guidelines : Apple interdit les apps qui collectent des données sans consentement ou qui violent les droits d'auteur. Préférez toujours les API officielles quand elles existent.

Consultez les docs ProxyHat pour plus d'informations sur l'usage acceptable, et la page tarifs pour les plans disponibles.

Points clés à retenir

• Configuration proxy : utilisez connectionProxyDictionary avec les clés kCFNetworkProxiesHTTP* et kCFNetworkProxiesHTTPS* pointant vers gate.proxyhat.com:8080.
• Authentification : kCFProxyUsernameKey/PasswordKey ne sont pas fiables. Préférez l'en-tête Proxy-Authorization: Basic ou un URLSessionDelegate gérant le 407.
• Géo-ciblage : encodez pays/ville/session dans le nom d'utilisateur, ex. user-country-US-city-newyork-session-abc123.
• SOCKS5 : port 1080 avec les clés kCFStreamPropertySOCKSProxy* pour le trafic non-HTTP.
• Production : retry avec backoff, gestion TLS, respect d'ATS, stockage sécurisé des credentials.
• Légalité : préférez les API officielles, respectez le robots.txt et le RGPD/CFAA.

FAQ

Qu'est-ce qu'utiliser un proxy en Swift ? C'est la configuration de URLSession pour acheminer le trafic HTTP/HTTPS/SOCKS5 via un serveur intermédiaire, en définissant connectionProxyDictionary sur URLSessionConfiguration avec les clés kCFNetworkProxies* appropriées.

Pourquoi utiliser un proxy en Swift pour les applications iOS ? Les proxies résidentiels permettent d'accéder à du contenu géo-verrouillé, d'éviter les blocages d'IP datacenter par les anti-bots, et de répartir les requêtes sur plusieurs IP pour le scraping à grande échelle sans être banni.

Quel type de proxy fonctionne le mieux pour le scraping en Swift ? Les proxies résidentiels offrent le meilleur compromis pour le scraping web : 90–98% de taux de succès contre 30–60% pour le datacenter sur les sites protégés. Les proxies mobiles sont supérieurs pour les réseaux sociaux mais plus coûteux.

Comment éviter les blocages avec un proxy Swift ? Utilisez la rotation d'IP (sessions uniques par requête), respectez les délais entre requêtes, gérez le challenge 407 via URLSessionDelegate, implémentez un retry avec backoff exponentiel, et alternez les User-Agents et pays via le géo-ciblage ProxyHat.

Le SDK ProxyHat existe-t-il pour Swift ? ProxyHat fournit des SDK Python et Node.js qui encapsulent le même gateway gate.proxyhat.com. En Swift, l'intégration se fait directement via URLSession comme montré dans ce guide, ce qui évite toute dépendance externe.