Guia para Usar um Proxy com HttpClient

Ao final deste guia de integração de proxy com HttpClient C#, você saberá:

O que é HttpClient e seu papel em fazer requisições HTTP no .NET
Por que você deve usar um proxy em C#
Como configurar um proxy no HttpClient
Como lidar com autenticação de proxy, erros de certificado SSL e rotação de IP com HttpClient.

Vamos começar!

O Que É HttpClient no .NET?

HttpClient é uma classe para fazer requisições HTTP e receber respostas HTTP no .NET. Faz parte do namespace System.Net.Http, representando o cliente HTTP padrão no .NET—e, portanto, em C#.

HttpClient suporta:

Todos os métodos HTTP, incluindo GET, POST, PUT, PATCH e DELETE
Comunicação assíncrona
Personalização de cabeçalhos e cookies
Personalização do corpo da requisição
Integração com proxy

Esses recursos, junto com seu suporte oficial na .NET Standard Library, fazem do HttpClient uma escolha popular para requisições HTTP em C#.

Por Que Você Precisa Configurar um Proxy no HttpClient de C#

Ao trabalhar com scraping de dados, coleta de dados ou outras tarefas relacionadas à internet, proteger sua identidade online é essencial. Uma forma de alcançar isso é roteando seu tráfego através de um servidor proxy.

Um servidor proxy atua como intermediário entre você e o site de destino, fornecendo estes benefícios ao HttpClient:

IP e localização ocultos: Os servidores de destino veem o IP do proxy, não o seu.
Confidencialidade aprimorada: Proxies adicionam uma camada de privacidade ao mascarar sua identidade real e dificultar seu rastreamento.
Evite banimentos de IP: Proxies ajudam a contornar limitadores de taxa, o que é fundamental no scraping de dados com C#.
Contorne restrições geográficas: Você pode usar servidores proxy localizados em regiões específicas para acessar conteúdo com restrição geográfica de casa.

Assim, usar proxies no HttpClient não apenas aumenta sua segurança online, mas também melhora a confiabilidade de suas tarefas de scraping.

Configure um Proxy com HttpClient em C#: Guia Passo a Passo

Siga os passos abaixo para aprender a integrar um proxy no HttpClient em .NET usando C#.

Pré-requisitos

Antes de começar, certifique-se de que você atende aos seguintes pré-requisitos:

Uma IDE C#: Você pode usar o Visual Studio ou o Visual Studio Code. Neste guia, usaremos o Visual Studio Code com a extensão C#.
.NET 8+ instalado localmente: Você precisa da versão mais recente do .NET ou qualquer versão LTS maior ou igual ao .NET 8. Este tutorial usará o .NET 9.

Se você não tiver as ferramentas necessárias, baixe-as usando o link acima e siga o assistente de instalação.

Passo #1: Configuração do Projeto

Crie uma nova pasta para seu projeto .NET e navegue até ela no terminal com os seguintes comandos:

mkdir httpclient-proxy
cd httpclient-proxy

Em seguida, inicialize uma nova aplicação Console .NET dentro dela:

dotnet run console

A saída deve ser:

The template "Console App" was created successfully.

Agora, abra a pasta do projeto em sua IDE:

Você deve ver os arquivos gerados pelo template, sendo Program.cs o mais importante. Atualmente, ele contém um simples script “Hello, World!”. Ao final desta seção, isso será um script de integração de proxy com HttpClient em C#.

Para garantir que tudo funcione como esperado, tente iniciar a aplicação C# com:

dotnet run

O resultado deve ser:

Hello, World!

Ótimo! Agora você tem um projeto C# funcional no Visual Studio Code.

Passo #2: Configure o HttpClient

Adicione as seguintes linhas de código ao Program.cs para enviar uma requisição usando HttpClient:

using System.Net;

class Program
{
  static async Task Main()
  {
    // inicializa uma instância do HttpClient
    using HttpClient client = new HttpClient();

    // a URL de destino
    string url = "https://httpbin.org/ip";

    // envia uma requisição GET assíncrona para o endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // lê o conteúdo da resposta como string
    string responseBody = await response.Content.ReadAsStringAsync();

    // imprime a resposta no console
    Console.WriteLine(responseBody);
  }
}

O trecho inicializa uma instância do HttpClient e usa seu método GetAsync() para se conectar ao endpoint GET /ip do projeto HTTPBin.io. Essa API retorna o endereço IP do chamador, tornando-a um alvo perfeito para verificar se a integração de proxy funciona como esperado. O motivo? Depois de integrar um proxy ao HttpClient, o IP retornado pelo endpoint /ip deve ser diferente do seu IP original.

Se você executar o script, a saída deve ser algo como:

{
  "origin": "55.17.80.196"
}

O endereço IP contido em origin representa seu IP de saída.

Incrível! Hora de obter uma URL de proxy válida.

Passo #3: Obtenha um Proxy

Para integrar um proxy ao HttpClient, primeiro você precisa de acesso a um servidor proxy.

Muitos portais online oferecem URLs de proxy gratuitas, mas tenha cuidado—manter uma infraestrutura de proxy é caro. Se um serviço oferece proxies gratuitos, considere qual pode ser seu modelo de negócio. Frequentemente, eles se envolvem em roubo de dados ou outras práticas questionáveis.

Por esse motivo, é melhor usar proxies gratuitos apenas para fins de aprendizado e evitá-los para uso em produção!

Se você precisar de proxies confiáveis, considere provedores confiáveis que oferecem testes gratuitos ou planos gratuitos limitados.

Agora, uma URL de proxy típica segue este formato:

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

Onde:

protocol especifica o tipo de proxy (ex.: http, https, socks5, etc.)
host: O domínio ou endereço IP do servidor proxy
port: O número da porta através da qual o tráfego é roteado

Neste exemplo, assumiremos que a URL do proxy é:

http://66.29.154.103:3128

Armazene isso em uma variável em Program.cs:

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

Hora de ver como usar um proxy com HttpClient!

Passo #4: Integração do Proxy

O HttpClient permite especificar um proxy através da classe HttpClientHandler. Isso fornece controle de baixo nível sobre as requisições HTTP enviadas por uma instância de HttpClient.

Em particular, HttpClientHandler tem uma propriedade Proxy que aceita um objeto WebProxy contendo as configurações do servidor proxy:

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

Em seguida, passe proxy para uma instância de HttpClientHandler:

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

E finalmente passe o HttpClientHandler para o construtor do HttpClient:

using HttpClient client = new HttpClient(handler);

Maravilha! Integração de proxy no HttpClient C# concluída.

Passo #5: Juntando Tudo

Seu script final de integração de proxy com HttpClient deve conter:

using System.Net;

class Program
{
  static async Task Main()
  {
    // inicializa um novo objeto proxy
    string proxyUrl = "http://66.29.154.103:3128"; // substitua por uma URL de proxy válida
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
    };

    // define um handler de cliente HTTP com o proxy dado
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // inicializa uma instância do HttpClient com integração de proxy
    using HttpClient client = new HttpClient(handler);

    // a URL de destino
    string url = "https://httpbin.org/ip";

    // envia uma requisição GET assíncrona para o endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // lê o conteúdo da resposta como string
    string responseBody = await response.Content.ReadAsStringAsync();

    // imprime a resposta no console
    Console.WriteLine(responseBody);
  }
}

Execute o script:

dotnet run

O resultado deve ser:

{
  "origin": "66.29.154.103"
}

Observe que o atributo origin na resposta do endpoint /ip exibe o endereço IP do servidor proxy. Isso confirma que seu IP real foi ocultado com sucesso atrás do proxy.

Aviso: Servidores proxy gratuitos geralmente têm vida curta e não são confiáveis. Quando você ler este guia, o proxy escolhido pode não funcionar mais. Para testar o código, substitua proxyUrl por uma URL de proxy válida e funcional antes de executar o script.

Casos de Uso Avançados para Integração de Proxy no HttpClient

Você acabou de aprender o básico da integração de proxy com HttpClient em C#, mas há outros cenários mais avançados a considerar.

Autenticação de Proxy

Proxies premium são protegidos com autenticação para restringir o acesso a usuários autorizados. Em particular, a URL de um proxy autenticado segue este formato:

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

Onde username e password são as credenciais usadas para autenticação.

No HttpClient, a autenticação de proxy é tratada usando a propriedade Credentials de WebProxy. Essa propriedade aceita um objeto NetworkCredential da seguinte forma:

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
  // especifica a autenticação do proxy
  Credentials = new NetworkCredential("<username>", "<password>"),
};

Extraia <username> e <password> da sua URL de proxy autenticado e substitua-os no código acima.

Assim, o código para integração de proxy autenticado fica:

using System.Net;

class Program
{
  static async Task Main()
  {
    // inicializa um novo objeto proxy
    string proxyUrl = "<protocol>://<host>:<port>";
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
      // especifica a autenticação do proxy
      Credentials = new NetworkCredential("<username>", "<password>"),
    };

    // define um handler de cliente HTTP com o proxy dado
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // inicializa uma instância do HttpClient com integração de proxy autenticado
    using HttpClient client = new HttpClient(handler);

    // a URL de destino
    string url = "https://httpbin.org/ip";

    // envia uma requisição GET assíncrona para o endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // lê o conteúdo da resposta como string
    string responseBody = await response.Content.ReadAsStringAsync();

    // imprime a resposta no console
    Console.WriteLine(responseBody);
  }
}

Evite Problemas com Certificado SSL

Ao configurar um proxy no HttpClient, suas requisições podem falhar devido ao erro de verificação de certificado SSL abaixo:

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

Isso geralmente acontece quando o proxy usa um certificado SSL autoassinado.

Se você confia no seu servidor proxy—e apenas nesse cenário, você pode desativar a verificação SSL para contornar esse problema usando a seguinte abordagem:

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

using HttpClient client = new HttpClient(handler);

O trecho acima sobrescreve o comportamento padrão de validação de certificado com um callback personalizado que sempre retorna true.

Nota: Desativar a verificação SSL torna sua conexão vulnerável a ataques MITM (Man-in-the-Middle). Use essa abordagem apenas se confiar totalmente no seu proxy e estiver ciente dos riscos de segurança.

Implemente a Rotação de Proxy

Se você depender repetidamente do mesmo servidor proxy, o site de destino pode eventualmente bloquear seu endereço IP. Para evitar isso, você pode rotacionar seus servidores proxy a cada requisição, para que suas requisições usem um servidor proxy diferente a cada vez.

Para implementar a rotação de proxy, siga este procedimento

Popule uma lista com várias URLs de proxy
Escolha aleatoriamente uma URL de proxy antes de cada requisição
Defina a URL de proxy escolhida no HttpClient

O algoritmo acima se traduz no seguinte trecho:

using System.Net;

class Program
{  
  static async Task Main()
  {
    // obtém uma URL de proxy aleatória
    string selectedProxyUrl = GetRandomProxyUrl();

    // configura o proxy aleatório
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = new WebProxy
      {
        Address = new Uri(selectedProxyUrl),
      },
    };

    // realiza uma requisição GET através do proxy aleatório
    using HttpClient client = new HttpClient(handler);
    string url = "https://httpbin.org/ip";
    HttpResponseMessage response = await client.GetAsync(url);

    // lê o conteúdo da resposta como string e imprime
    string responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
  }

  static string GetRandomProxyUrl()
  {
    // a lista de URLs de proxy para rotacionar
    List<string> proxyUrls = new List<string>
        {
            "<protocol_1>://<proxy_host_1>:<port_1>",
            // ...
            "<protocol_n>://<proxy_host_n>:<port_n>",
        };

    // retorna uma URL de proxy aleatória da lista
    Random random = new Random();
    int index = random.Next(proxyUrls.Count);
    return proxyUrls[index];
  }
}

As principais desvantagens dessa abordagem são:

Envolve código repetitivo
Requer acesso a um pool de servidores proxy confiáveis, o que geralmente tem um custo

Felizmente, há uma solução mais eficiente para rotacionar um endereço IP em C#!

A Bright Data fornece proxies rotativos que rotacionam automaticamente os endereços IP de saída, eliminando a necessidade de rotação manual de proxy. Eles contam com cerca de 100 milhões de IPs, estão disponíveis em 195 países, têm excelente tempo de atividade da rede e garantem uma taxa de sucesso de 99,9%.

No próximo capítulo, você aprenderá como começar a usar os proxies rotativos da Bright Data no HttpClient.

Use um Proxy da Bright Data no HttpClient

A Bright Data opera um dos maiores servidores proxy do mundo, atendendo empresas da Fortune 500 e 50,000+ clientes. Esta rede de proxy mundial inclui:

Proxies de datacenter – Mais de 1,300,000+ IPs de datacenter.
Proxies residenciais – Mais de 400M+ IPs residenciais em mais de 195 países.
Proxies ISP – Mais de 1,300,000+ IPs ISP.

Siga os passos abaixo para aprender a usar os proxies residenciais da Bright Data com HttpClient em C#.

Se você já tem uma conta, faça login na Bright Data. Caso contrário, crie uma conta e, uma vez logado, você será direcionado ao seu painel de usuário:

Clique no botão “View proxy products” para continuar:

Você será redirecionado para a página “Proxies & Scraping Infrastructure”:

Página principal de Proxies e Infraestrutura de Scraping

Role para baixo e encontre o card “Residential Proxies”. Clique no botão “Get started”:

Na página de configuração do proxy residencial, siga o assistente para personalizar o serviço de acordo com suas necessidades. Se tiver dúvidas, sinta-se à vontade para entrar em contato com o suporte 24/7:

Personalizando o serviço de acordo com suas necessidades

Vá para a aba “Access parameters” para obter o host, porta, nome de usuário e senha do seu proxy:

Os parâmetros de acesso para sua nova zona

Observe que o campo “Host” inclui a porta.

Agora que você tem os detalhes necessários, construa a URL do seu proxy e use-a com o objeto WebProxy em C#:

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

Substitua os espaços reservados <...> pelas informações do seu proxy da Bright Data.

Ative a configuração “Active proxy”, siga as instruções restantes e está tudo pronto!

Use o seguinte trecho de código C# para integrar o proxy da Bright Data ao HttpClient:

using System.Net;

class Program
{
  static async Task Main()
  {
    // inicializa um novo objeto proxy
    WebProxy proxy = new WebProxy
    {
      // TODO: substitua os espaços reservados pelas informações do seu proxy da Bright Data
      Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
      Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
    };

    // define um handler de cliente HTTP com o proxy dado
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // desativa a verificação SSL
    handler.ClientCertificateOptions = ClientCertificateOption.Manual;
    handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
    {
      return true;
    };

    // inicializa uma instância do HttpClient com integração de proxy
    using HttpClient client = new HttpClient(handler);

    // a URL de destino
    string url = "https://httpbin.org/ip";

    // envia uma requisição GET assíncrona para o endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // lê o conteúdo da resposta como string
    string responseBody = await response.Content.ReadAsStringAsync();

    // imprime a resposta no console
    Console.WriteLine(responseBody);
  }
}

Toda vez que você executar o script acima, verá um IP de saída diferente.

A rotação de proxy no HttpClient nunca foi tão fácil com os proxies de rotação automática da Bright Data!

Conclusão

Neste tutorial de integração de proxy, você aprendeu por que usar proxies é importante e como integrá-los com HttpClient em C#. Você descobriu como é fácil configurar um proxy no HttpClient, a biblioteca de cliente HTTP padrão no .NET.

Através deste guia, você também entendeu por que confiar em serviços de proxy gratuitos é arriscado. Em vez disso, você precisa usar proxies confiáveis de um provedor de proxy respeitável. E quando se trata do melhor provedor de proxy rotativo do mercado, não procure mais, a Bright Data é a resposta.

Crie uma conta e comece a testar nossos proxies gratuitamente hoje mesmo!

Contate-nos Comece agora