Guide pour utiliser un proxy avec HttpClient

À la fin de ce guide d’intégration de proxy HttpClient C#, vous saurez :

Ce qu’est HttpClient et son rôle dans les requêtes HTTP en .NET
Pourquoi vous devriez utiliser un proxy en C#
Comment configurer un proxy dans HttpClient
Comment gérer l’authentification proxy, les erreurs de certificat SSL et la rotation d’IP avec HttpClient.

Plongeons dans le sujet !

Qu’est-ce que HttpClient en .NET ?

HttpClient est une classe permettant d’effectuer des requêtes HTTP et de recevoir des réponses HTTP en .NET. Elle fait partie de l’espace de noms System.Net.Http, représentant le client HTTP par défaut en .NET — et donc en C#.

HttpClient prend en charge :

Toutes les méthodes HTTP, y compris GET, POST, PUT, PATCH et DELETE
La communication asynchrone
La personnalisation des en-têtes et des cookies
La personnalisation du corps de la requête
L’intégration de proxy

Ces fonctionnalités, ainsi que sa prise en charge officielle dans la bibliothèque standard .NET, font de HttpClient un choix populaire pour les requêtes HTTP en C#.

Pourquoi configurer un proxy dans C# HttpClient

Lorsque vous travaillez avec le scraping web, la collecte de données ou d’autres tâches liées à Internet, protéger votre identité en ligne est essentiel. Une façon d’y parvenir est d’acheminer votre trafic via un serveur proxy.

Un serveur proxy agit comme intermédiaire entre vous et le site de destination, offrant ces avantages à HttpClient :

IP et localisation masquées : Les serveurs de destination voient l’IP du proxy, pas la vôtre.
Confidentialité renforcée : Les proxys ajoutent une couche de confidentialité en masquant votre véritable identité, rendant le suivi plus difficile.
Éviter les bannissements d’IP : Les proxys vous aident à contourner les limiteurs de débit, ce qui est fondamental dans le scraping web avec C#.
Contourner les restrictions géographiques : Vous pouvez utiliser des serveurs proxy situés dans des régions spécifiques pour accéder à du contenu géo-restreint depuis chez vous.

Ainsi, l’utilisation de proxys dans HttpClient augmente non seulement votre sécurité en ligne, mais améliore également la fiabilité de vos tâches de scraping.

Configurer un proxy avec HttpClient en C# : guide étape par étape

Suivez les étapes ci-dessous pour apprendre à intégrer un proxy dans HttpClient en .NET avec C#.

Prérequis

Avant de commencer, assurez-vous de respecter les prérequis suivants :

Un IDE C# : Vous pouvez utiliser soit Visual Studio, soit Visual Studio Code. Dans ce guide, nous utiliserons Visual Studio Code avec l’extension C#.
.NET 8+ installé localement : Vous avez besoin de la dernière version de .NET ou de toute version LTS supérieure ou égale à .NET 8. Ce tutoriel utilisera .NET 9.

Si vous ne disposez pas des outils requis, téléchargez-les via le lien ci-dessus et suivez l’assistant d’installation.

Étape n°1 : Configuration du projet

Créez un nouveau dossier pour votre projet .NET et accédez-y dans le terminal avec les commandes suivantes :

mkdir httpclient-proxy
cd httpclient-proxy

Ensuite, initialisez une nouvelle application console .NET à l’intérieur :

dotnet run console

La sortie devrait être :

The template "Console App" was created successfully.

Ouvrez maintenant le dossier du projet dans votre IDE :

Vous devriez voir les fichiers générés par le modèle, Program.cs étant le plus important. Actuellement, il contient un simple script “Hello, World!”. À la fin de cette section, ce sera un script d’intégration de proxy HttpClient C#.

Pour vérifier que tout fonctionne comme prévu, essayez de lancer l’application C# avec :

dotnet run

Le résultat devrait être :

Hello, World!

Parfait ! Vous avez maintenant un projet C# fonctionnel dans Visual Studio Code.

Étape n°2 : Configurer HttpClient

Ajoutez les lignes de code suivantes à Program.cs pour envoyer une requête avec HttpClient :

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize an HttpClient instance
    using HttpClient client = new HttpClient();

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Cet extrait initialise une instance HttpClient et utilise sa méthode GetAsync() pour se connecter au point de terminaison GET /ip du projet HTTPBin.io. Cette API renvoie l’adresse IP de l’appelant, ce qui en fait une cible parfaite pour vérifier si l’intégration du proxy fonctionne comme prévu. Pourquoi ? Une fois que vous avez intégré un proxy dans HttpClient, l’IP renvoyée par le point de terminaison /ip doit être différente de votre IP d’origine.

Si vous exécutez le script, la sortie devrait ressembler à :

{
  "origin": "55.17.80.196"
}

L’adresse IP contenue dans origin représente votre IP de sortie.

Incroyable ! Il est temps d’obtenir une URL de proxy valide.

Étape n°3 : Récupérer un proxy

Pour intégrer un proxy dans HttpClient, vous devez d’abord avoir accès à un serveur proxy.

De nombreux portails en ligne proposent des URL de proxy gratuites, mais soyez prudent — faire fonctionner une infrastructure de proxy coûte cher. Si un service propose des proxys gratuits, réfléchissez à son modèle économique. Souvent, ils se livrent au vol de données ou à d’autres pratiques douteuses.

Pour cette raison, il est préférable d’utiliser des proxys gratuits uniquement à des fins d’apprentissage et de les éviter en production !

Si vous avez besoin de proxys fiables, envisagez des fournisseurs réputés qui offrent des essais gratuits ou des forfaits gratuits limités.

Une URL de proxy typique suit ce format :

<protocol>://<host>:<port>

Où :

protocol spécifie le type de proxy (par exemple, http, https, socks5, etc.)
host : Le domaine ou l’adresse IP du serveur proxy
port : Le numéro de port par lequel le trafic est acheminé

Dans cet exemple, nous supposerons que l’URL du proxy est :

http://66.29.154.103:3128

Stockez-la dans une variable dans Program.cs :

string proxyUrl = "http://66.29.154.103:3128";

Il est temps de voir comment utiliser un proxy avec HttpClient !

Étape n°4 : Intégration du proxy

HttpClient vous permet de spécifier un proxy via la classe HttpClientHandler. Cela offre un contrôle de bas niveau sur les requêtes HTTP envoyées par une instance HttpClient.

En particulier, HttpClientHandler possède une propriété Proxy qui accepte un objet WebProxy contenant les paramètres du serveur proxy :

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
};

Ensuite, passez proxy à une instance HttpClientHandler :

HttpClientHandler handler = new HttpClientHandler
{
    Proxy = proxy,
};

Et enfin, passez HttpClientHandler au constructeur HttpClient :

using HttpClient client = new HttpClient(handler);

Formidable ! Intégration du proxy HttpClient C# terminée.

Étape n°5 : Assembler le tout

Votre script final d’intégration de proxy HttpClient devrait contenir :

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    string proxyUrl = "http://66.29.154.103:3128"; // replace with a valid proxy URL
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // initialize an HttpClient instance with proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Exécutez le script :

dotnet run

Le résultat devrait être :

{
  "origin": "66.29.154.103"
}

Notez que l’attribut origin dans la réponse du point de terminaison /ip affiche l’adresse IP du serveur proxy. Cela confirme que votre véritable IP a bien été masquée derrière le proxy.

Avertissement : Les serveurs proxy gratuits sont généralement éphémères et peu fiables. Au moment où vous lirez ce guide, le proxy choisi ne fonctionnera probablement plus. Pour tester le code, remplacez proxyUrl par une URL de proxy valide et fonctionnelle avant d’exécuter le script.

Cas d’usage avancés pour l’intégration de proxy HttpClient

Vous venez d’apprendre les bases de l’intégration de proxy avec HttpClient en C#, mais il existe d’autres scénarios plus avancés à considérer.

Authentification du proxy

Les proxys premium sont protégés par authentification pour restreindre l’accès aux utilisateurs autorisés. En particulier, l’URL d’un proxy authentifié suit ce format :

<protocol>://<username>:<password>@<host>:<port>

Où username et password sont les identifiants utilisés pour l’authentification.

Dans HttpClient, l’authentification du proxy est gérée à l’aide de la propriété Credentials de WebProxy. Cette propriété accepte un objet NetworkCredential comme suit :

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
  // specify proxy authentication
  Credentials = new NetworkCredential("<username>", "<password>"),
};

Extrayez <username> et <password> de votre URL de proxy authentifié et remplacez-les dans le code ci-dessus.

Ainsi, le code pour l’intégration d’un proxy authentifié devient :

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    string proxyUrl = "<protocol>://<host>:<port>";
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
      // specify proxy authentication
      Credentials = new NetworkCredential("<username>", "<password>"),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // initialize an HttpClient instance with authenticated proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Éviter les problèmes de certificat SSL

Lors de la configuration d’un proxy dans HttpClient, vos requêtes peuvent échouer en raison de l’erreur de vérification du certificat SSL ci-dessous :

Unhandled exception. System.Net.Http.HttpRequestException: The SSL connection could not be established, see inner exception.
 ---> System.Security.Authentication.AuthenticationException: The remote certificate is invalid because of errors in the certificate chain: UntrustedRoot

Cela se produit généralement lorsque le proxy utilise un certificat SSL auto-signé.

Si vous faites confiance à votre serveur proxy — et uniquement dans ce cas — vous pouvez désactiver la vérification SSL pour contourner ce problème avec l’approche suivante :

HttpClientHandler handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
{
  return true;
};

using HttpClient client = new HttpClient(handler);

L’extrait ci-dessus remplace le comportement de validation de certificat par défaut par un callback personnalisé qui renvoie toujours true.

Remarque : Désactiver la vérification SSL rend votre connexion vulnérable aux attaques MITM (Man-in-the-Middle). N’utilisez cette approche que si vous faites entièrement confiance à votre proxy et que vous êtes conscient des risques de sécurité.

Implémenter la rotation de proxy

Si vous vous appuyez à répétition sur le même serveur proxy, le site cible pourrait finir par bloquer son adresse IP. Pour éviter cela, vous pouvez faire tourner vos serveurs proxy à chaque requête, afin que vos requêtes utilisent un serveur proxy différent à chaque fois.

Pour implémenter la rotation de proxy, suivez cette procédure

Remplissez une liste avec plusieurs URL de proxy
Choisissez aléatoirement une URL de proxy avant chaque requête
Définissez l’URL de proxy choisie dans HttpClient

L’algorithme ci-dessus se traduit par l’extrait suivant :

using System.Net;

class Program
{  
  static async Task Main()
  {
    // get a random proxy URL
    string selectedProxyUrl = GetRandomProxyUrl();

    // configure the random proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = new WebProxy
      {
        Address = new Uri(selectedProxyUrl),
      },
    };

    // perform a GET request through the random proxy
    using HttpClient client = new HttpClient(handler);
    string url = "https://httpbin.org/ip";
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string and print it
    string responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
  }

  static string GetRandomProxyUrl()
  {
    // the list of proxy URL to rotate from
    List<string> proxyUrls = new List<string>
        {
            "<protocol_1>://<proxy_host_1>:<port_1>",
            // ...
            "<protocol_n>://<proxy_host_n>:<port_n>",
        };

    // return a random proxy URL from the list
    Random random = new Random();
    int index = random.Next(proxyUrls.Count);
    return proxyUrls[index];
  }
}

Les principaux inconvénients de cette approche sont :

Elle implique du code répétitif
Elle nécessite l’accès à un pool de serveurs proxy fiables, ce qui a généralement un coût

Heureusement, il existe une solution plus efficace pour faire tourner une adresse IP en C# !

Bright Data fournit des proxys rotatifs qui font automatiquement tourner les adresses IP de sortie, éliminant ainsi le besoin de rotation manuelle. Ils disposent d’environ 100 millions d’IP, sont disponibles dans 195 pays, offrent une disponibilité réseau exceptionnelle et garantissent un taux de réussite de 99,9 %.

Dans le prochain chapitre, vous apprendrez à démarrer avec les proxys rotatifs de Bright Data dans HttpClient.

Utiliser un proxy Bright Data dans HttpClient

Bright Data exploite l’un des plus grands serveurs proxy au monde, au service des entreprises du Fortune 500 et de 50,000+ clients. Ce réseau de proxy mondial comprend :

Proxys de centre de données – Plus de 1,300,000+ IP de centre de données.
Proxys résidentiels – Plus de 400M+ IPs résidentielles dans plus de 195 pays.
Proxys ISP – Plus de 1,300,000+ IP ISP.

Suivez les étapes ci-dessous pour apprendre à utiliser les proxys résidentiels de Bright Data avec HttpClient en C#.

Si vous avez déjà un compte, connectez-vous à Bright Data. Sinon, créez un compte et, une fois connecté, vous serez dirigé vers votre tableau de bord utilisateur :

Cliquez sur le bouton « View proxy products » pour continuer :

Vous serez redirigé vers la page « Proxies & Scraping Infrastructure » :

Proxies & Scraping Infrastructure main page

Faites défiler vers le bas et trouvez la carte « Residential Proxies ». Cliquez sur le bouton « Get started » :

Getting started with residential proxies

Sur la page de configuration du proxy résidentiel, suivez l’assistant pour personnaliser le service selon vos besoins. Pour toute question, n’hésitez pas à contacter le support 24/7 :

Customizing the service based on your needs

Accédez à l’onglet « Access parameters » pour récupérer l’hôte, le port, le nom d’utilisateur et le mot de passe de votre proxy :

Notez que le champ « Host » inclut le port.

Maintenant que vous disposez des informations nécessaires, construisez l’URL de votre proxy et utilisez-la avec l’objet WebProxy en C# :

WebProxy proxy = new WebProxy
{
  Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
  Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
};

Remplacez les espaces réservés <...> par les informations de votre proxy Bright Data.

Activez le paramètre « Active proxy », suivez les instructions restantes, et le tour est joué !

Utilisez l’extrait de code C# suivant pour intégrer le proxy Bright Data dans HttpClient :

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    WebProxy proxy = new WebProxy
    {
      // TODO: replace the placeholders with your Bright Data's proxy info
      Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
      Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // disable SSL verification
    handler.ClientCertificateOptions = ClientCertificateOption.Manual;
    handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
    {
      return true;
    };

    // initialize an HttpClient instance with proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Chaque fois que vous exécutez le script ci-dessus, vous verrez une IP de sortie différente.

La rotation de proxy HttpClient n’a jamais été aussi simple grâce aux proxys auto-rotatifs de Bright Data !

Conclusion

Dans ce tutoriel d’intégration de proxy, vous avez appris pourquoi l’utilisation de proxys est importante et comment les intégrer avec HttpClient en C#. Vous avez découvert à quel point il est facile de configurer un proxy dans HttpClient, la bibliothèque client HTTP par défaut en .NET.

Grâce à ce guide, vous avez également compris pourquoi s’appuyer sur des services de proxy gratuits est risqué. À la place, vous devez utiliser des proxys fiables provenant d’un fournisseur de proxy réputé. Et quand il s’agit du meilleur fournisseur de proxy rotatif du marché, ne cherchez pas plus loin que Bright Data.

Créez un compte et commencez à tester nos proxys gratuitement dès aujourd’hui !

Contactez-nous Commencer