---
title: "Como configurar servidores proxy em C#"
slug: proxy-with-c-sharp
date: 2024-02-28T07:34:59+00:00
modified: 2026-04-27T08:43:14+00:00
permalink: https://brightdata.com.br/blog/procedimentos/proxy-with-c-sharp
type: blog
---

[ Blog ](https://brightdata.com.br/blog "Blog") / [procedimentos](https://brightdata.com.br/blog/procedimentos)







 [procedimentos](https://brightdata.com.br/blog/procedimentos)

# Como configurar servidores proxy em C#

Aprenda a implementar proxies em C# para web scraping, aprimorando a privacidade e a eficiência em projetos de extração de dados com Visual Studio e o .NET 7.

 18 min de leitura





 [ ![White number one with a flame on top.](https://media.brightdata.com.br/2023/03/Favicon-2-1-50x50.png) ](https://brightdata.com/blog/authors/abnoan-muniz)

 [Abnoan Muniz

February 28, 2024

 ](https://brightdata.com/blog/authors/abnoan-muniz)





 ![Configuring Proxy Settings in C# Code](https://media.brightdata.com.br/2024/02/Setting-Proxy-in-C.svg)





Quando você acessa a internet diretamente, os sites podem facilmente rastrear suas solicitações até chegar ao seu endereço IP. Essa exposição pode levar a publicidade direcionada e rastreamento on-line e potencialmente comprometer sua identidade digital.

É aí que entram os proxies. Eles atuam como intermediários entre seu computador e a internet e ajudam você a proteger sua identidade digital. Quando você usa um servidor proxy, ele envia solicitações para os sites em seu nome usando o próprio endereço IP do proxy.

Quando se trata de web scraping, os proxies podem ajudar você a contornar banimentos de IP, evitar o bloqueio geográfico e proteger sua identidade. Neste artigo, você aprenderá como implementar proxies em C# para todos os seus projetos de web scraping.

## <a></a>Pré-requisitos

Antes de começar este tutorial, certifique-se de ter o seguinte:

- Visual Studio 2022
- .NET 7 ou mais recente
- HTMLAgilityPack

Os exemplos neste artigo usam um aplicativo de console .NET separado. Para criar o seu próprio, você pode usar um dos seguintes guias:

- [Crie um aplicativo de console .NET usando o Visual Studio Code](https://learn.microsoft.com/en-us/dotnet/core/tutorials/with-visual-studio-code?pivots=dotnet-7-0)
- [Crie um aplicativo de console .NET usando o Visual Studio](https://learn.microsoft.com/en-us/dotnet/core/tutorials/with-visual-studio?pivots=dotnet-7-0)

Para começar, você precisa criar dois aplicativos de console, `WebScrapApp` e `WebScrapBrightData`:

![Criando o webscrapeapp e webscrapbrightdata no VS](https://media.brightdata.com.br/2024/02/create-webscrapapp-and-webscrapbrightdata.png)Para web scraping, especialmente se você estiver lidando com conteúdo HTML, você precisa de ferramentas específicas, como o HTMLAgilityPack. Essa biblioteca simplifica a análise e a manipulação de HTML, facilitando a extração de dados das páginas web.

Em ambos os projetos (*ou seja,* `WebScrapApp` e `WebScrapBrightData`), adicione o pacote HTMLAgilityPack do NuGet clicando com o botão direito do mouse na pasta **NuGet** e depois em **Gerenciar pacotes NuGet**. Quando uma janela pop-up aparecer, pesquise por “HTMLAgilityPack” e instale-o para os dois projetos:

![Instalação do HTMLAgilityPack no VS](https://media.brightdata.com.br/2024/02/HtmlAgilityPack-installation.png)Para executar qualquer um dos projetos a seguir, você precisa navegar até o diretório do projeto no prompt de comando e usar `cd pathtoyourproject` seguido por `dotnet run`. Como alternativa, você pode pressionar **F5** para criar e executar o projeto no Visual Studio. Ambos os métodos compilam e executam seu aplicativo, exibindo a saída de acordo.

> **Nota:** se você não tiver o Visual Studio 2022, poderá usar qualquer IDE alternativo com suporte ao .NET 7. Lembre-se de que algumas etapas deste guia podem variar.

## <a></a>Como configurar um proxy local

Quando se trata de web scraping, a primeira coisa que você precisa fazer é usar um servidor proxy. Este tutorial usa o proxy de código aberto [mitmproxy](https://mitmproxy.org/).

Para começar, navegue até [mitmproxy downloads](https://mitmproxy.org/downloads/#10.1.6/), baixe a versão 10.1.6 e selecione a versão correta para seu sistema operacional. Para obter ajuda adicional, confira o [guia oficial de instalação do mitmproxy](https://docs.mitmproxy.org/stable/overview-installation/).

Depois de instalar o mitmproxy, abra seu terminal e inicialize o mitmproxy usando o seguinte comando:

```none
mitmproxy

```

Deve aparecer uma janela em seu shell ou terminal parecida com esta:

![Janela do shell após a inicialização do mitmproxy](https://media.brightdata.com.br/2024/02/Shell-window.png)Para testar o proxy, abra outro terminal ou shell e execute a seguinte solicitação curl:

```none
 curl --proxy http://localhost:8080 "http://wttr.in/Dunedin?0"

```

O resultado deve ser semelhante a este:

```none
Weather report: Dunedin

                Cloudy
       .--.     +11(9) °C
    .-(    ).   ↙ 15 km/h
   (___.__)__)  10 km
                0.0 mm

```

Na janela do mitmproxy, você deve ver que ele interceptou a chamada por meio do proxy local:

![uma chamada por meio de um proxy local na janela do mitmproxy](https://media.brightdata.com.br/2024/02/a-call-through-a-local-proxy-in-the-mitmproxy-window.png)## <a></a>Web scraping em C#

Na seção a seguir, você configurará o aplicativo de console em C# `WebScrapApp` para web scraping. Esse aplicativo utiliza o servidor proxy e inclui rotação de proxies para maior eficiência.

### <a></a>Crie um HttpClient

A classe `ProxyHttpClient` foi projetada para configurar uma instância `HttpClient` para rotear solicitações por meio de um servidor proxy especificado.

Em seu projeto `WebScrapApp` , crie um novo arquivo de classe chamado `ProxyHttpClient.cs` e adicione o seguinte código:

```none
namespace WebScrapApp
{
    public class ProxyHttpClient
    {
        public static HttpClient CreateClient(string proxyUrl)
        {
            var httpClientHandler = new HttpClientHandler()
            {
                Proxy = new WebProxy(proxyUrl),
                UseProxy = true
            };
            return new HttpClient(httpClientHandler);
        }
    }
}

```

### <a></a>Implementar a rotação de proxies

Para implementar a rotação de proxies, crie um arquivo de classe `ProxyRotator.cs` em sua solução `WebScrapApp`:

```none
namespace WebScrapApp
{
    public class ProxyRotator
    {
        private List<string> _validProxies = new List<string>();
        private readonly Random _random = new();

        public ProxyRotator(string[] proxies, bool isLocal)
        {
            if (isLocal)
            {
                _validProxies.Add("http://localhost:8080/");
            }
            else
            {
                _validProxies = ProxyChecker.GetWorkingProxies(proxies.ToList()).Result;
            }
            if (_validProxies.Count == 0)
                throw new InvalidOperationException();
        }

        public HttpClient ScrapeDataWithRandomProxy(string url)
        {
            if (_validProxies.Count == 0)
                throw new InvalidOperationException();

            var proxyUrl = _validProxies[_random.Next(_validProxies.Count)];
            return ProxyHttpClient.CreateClient(proxyUrl);
        }
    }
}

```

Essa classe gerencia uma lista de proxies, fornecendo um método para selecionar aleatoriamente um proxy para cada solicitação da web. Essa randomização é fundamental para reduzir o risco de detecção e possíveis banimentos de IP durante a extração de dados da web.

Quando `isLocal` está definido como `True`, ele usa o proxy local do mitmproxy. Se estiver definido como `False`, ele usa os IPs públicos dos proxies.

O `ProxyChecker` é usado para validar a lista de servidores proxy.

Em seguida, crie um novo arquivo de classe chamado `ProxyChecker.cs` e adicione o seguinte código:

```none
using WebScrapApp;

namespace WebScrapApp
{
    public class ProxyChecker
    {
        private static SemaphoreSlim consoleSemaphore = new SemaphoreSlim(1, 1);
        private static int currentProxyNumber = 0;

        public static async Task<List<string>> GetWorkingProxies(List<string> proxies)
        {
            var tasks = new List<Task<Tuple<string, bool>>>();

            foreach (var proxyUrl in proxies)
            {
                tasks.Add(CheckProxy(proxyUrl, proxies.Count));
            }

            var results = await Task.WhenAll(tasks);

            var workingProxies = new List<string>();
            foreach (var result in results)
            {
                if (result.Item2)
                {
                    workingProxies.Add(result.Item1);
                }
            }

            return workingProxies;
        }

        private static async Task<Tuple<string, bool>> CheckProxy(string proxyUrl, int totalProxies)
        {
            var client = ProxyHttpClient.CreateClient(proxyUrl);
            bool isWorking = await IsProxyWorking(client);

            await consoleSemaphore.WaitAsync();
            try
            {
                currentProxyNumber++;
                Console.WriteLine($"Proxy: {currentProxyNumber} de {totalProxies}");
            }
            finally
            {
                consoleSemaphore.Release();
            }

            return new Tuple<string, bool>(proxyUrl, isWorking);
        }

        private static async Task<bool> IsProxyWorking(HttpClient client)
        {
            try
            {
                var testUrl = "http://www.google.com";
                var response = await client.GetAsync(testUrl);
                return response.IsSuccessStatusCode;
            }
            catch
            {
                return false;
            }
        }
    }

}

```

Esse código define o `ProxyChecker` para validar uma lista de servidores proxy. Quando você usa o método `getWorkingProxies` com uma lista de URLs de proxy, ele verifica o status de cada proxy de forma assíncrona por meio do método `checkProxy` , reunindo proxies operacionais em uma lista `WorkingProxies` . Em `checkProxy`, você estabelece um `HttpClient` com o URL do proxy, faz uma solicitação de teste para [http://www.google.com](https://www.google.com/)e registra o progresso com segurança usando um semáforo.

O método `isProxyWorking` confirma a funcionalidade do proxy examinando o código de status da resposta, retornando `true` para proxies operacionais. Essa classe ajuda na identificação de proxies funcionais de uma determinada lista.

### <a></a>Extrair dados da web

Para extrair dados, crie um novo arquivo de classe `WebScraper.cs` em sua solução `WebScrapApp` e adicione o seguinte código:

```none
using HtmlAgilityPack;

namespace WebScrapApp
{
    public class WebScraper
    {
        public static async Task ScrapeData(ProxyRotator proxyRotator, string url)
        {
            try
            {
                var client = proxyRotator.ScrapeDataWithRandomProxy(url);

                // Use HttpClient to make an asynchronous GET request
                var response = await client.GetAsync(url);
                var content = await response.Content.ReadAsStringAsync();

                // Load the HTML content into an HtmlDocument
                HtmlDocument doc = new();
                doc.LoadHtml(content);

                // Use XPath to find all <a> tags that are direct children of <li>, <p>, or <td>
                var nodes = doc.DocumentNode.SelectNodes("//li/a[@href] | //p/a[@href] | //td/a[@href]");

                if (nodes != null)
                {
                    foreach (var node in nodes)
                    {
                        string hrefValue = node.GetAttributeValue("href", string.Empty);
                        string title = node.InnerText; // This gets the text content of the <a> tag, which is usually the title

                        // Since Wikipedia URLs are relative, we need to convert them to absolute
                        Uri baseUri = new(url);
                        Uri fullUri = new(baseUri, hrefValue);

                        Console.WriteLine($"Title: {title}, Link: {fullUri.AbsoluteUri}");
                        // You can process each title and link as required
                    }
                }
                else
                {
                    Console.WriteLine("No article links found on the page.");
                }

                // Add additional logic for other data extraction as needed
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}

```

Nesse código, você define o `WebScraper`, que encapsula a funcionalidade de web scraping. Ao chamar o método `ScrapeData` , você fornece a ele uma instância `ProxyRotator` e um URL de destino. Dentro desse método, você usa um `HttpClient` para fazer uma solicitação GET assíncrona para o URL, recuperar o conteúdo HTML e analisá-lo usando a biblioteca HTMLAgilityPack. Em seguida, você usa consultas XPath para localizar e extrair links e títulos correspondentes de elementos HTML específicos. Se algum link de artigo for encontrado, você imprime seus títulos e URLs absolutos. Do contrário, você imprime uma mensagem indicando que nenhum link foi encontrado.

Depois de configurar o mecanismo de rotação de proxies e implementar a funcionalidade de web scraping, você precisa integrar perfeitamente esses componentes ao ponto de entrada principal do aplicativo, que normalmente é encontrado em `Program.cs`. Essa integração permite que o aplicativo execute tarefas de extração de dados na web enquanto utiliza proxies rotativos com um foco específico na extração de dados da página inicial da Wikipedia:

```none
namespace WebScrapApp {
    public class Program
    {
        static async Task Main(string[] args)
        {
            string[] proxies = {
            "http://162.223.89.84:80",
            "http://203.80.189.33:8080",
            "http://94.45.74.60:8080",
            "http://162.248.225.8:80",
            "http://167.71.5.83:3128"
        };

            var proxyRotator = new ProxyRotator(proxies, false);
            string urlToScrape = "https://www.wikipedia.org/";
            await WebScraper.ScrapeData(proxyRotator, urlToScrape);
        }
    }

}

```

Nesse código, o aplicativo inicializa uma lista de URLs de proxy, cria uma instância `ProxyRotator` , especifica o URL de destino para extração (nesse caso, `https://www.wikipedia.org/`) e invoca o método `webScraper.scrapeData` para iniciar o processo de web scraping.

O aplicativo usa uma lista de IPs de proxies gratuitos, especificada no array de proxies, para rotear solicitações de web scraping, mascarando a fonte confiável e minimizando o risco de ser bloqueado pelo servidor da Wikipedia. O método `ScrapeData` está configurado para extrair dados da página inicial da Wikipedia para extrair e exibir títulos e links de artigos no console. A classe `ProxyRotator` manipula a rotação desses proxies, aumentando a discrição do scraping.

### <a></a>Executar o WebScrapApp

Para executar o `WebScrapApp`, abra um novo terminal ou shell no diretório raiz do seu aplicativo `WebScrapApp` e execute os seguintes comandos:

```none
dotnet build
dotnet run

```

O resultado deve ser semelhante a este:

```none
…output omitted…
Title: Latina, Link: https://la.wikipedia.org/
Title: Latviešu, Link: https://lv.wikipedia.org/
Title: Lietuvių, Link: https://lt.wikipedia.org/
Title: Magyar, Link: https://hu.wikipedia.org/
Title: Македонски, Link: https://mk.wikipedia.org/
Title: Bahasa Melayu, Link: https://ms.wikipedia.org/
Title: Bahaso Minangkabau, Link: https://min.wikipedia.org/
Title: bokmål, Link: https://no.wikipedia.org/
Title: nynorsk, Link: https://nn.wikipedia.org/
Title: Oʻzbekcha / Ўзбекча, Link: https://uz.wikipedia.org/
Title: Қазақша / Qazaqşa / قازاقشا, Link: https://kk.wikipedia.org/
Title: Română, Link: https://ro.wikipedia.org/
Title: Simple English, Link: https://simple.wikipedia.org/
Title: Slovenčina, Link: https://sk.wikipedia.org/
Title: Slovenščina, Link: https://sl.wikipedia.org/
Title: Српски / Srpski, Link: https://sr.wikipedia.org/
Title: Srpskohrvatski / Српскохрватски, Link: https://sh.wikipedia.org/
Title: Suomi, Link: https://fi.wikipedia.org/
Title: தமிழ், Link: https://ta.wikipedia.org/
…output omitted…

```

Quando o método `ScrapeData` da classe `WebScraper` é invocado, ele executa a extração de dados da Wikipedia, resultando na exibição dos títulos dos artigos e seus links correspondentes no console. Esse código usa proxies disponíveis publicamente e, toda vez que você executa o aplicativo, ele escolhe um dos endereços IP listados como proxy.

Para testar com o proxy local do mitmproxy, atualize o método `ProxyRotator` no arquivo `Program` com o seguinte:

```none
var proxyRotator = new ProxyRotator(proxies, true)
 string urlToScrape = "http://toscrape.com/";

```

Ao definir o valor como `true`, ele usa o servidor proxy local que está sendo executado na porta 8080 do seu localhost (*ou seja,* o servidor mitmproxy).

Para simplificar o processo de configuração de um certificado em sua máquina, altere o URL para `http://toscrape.com/`.

Verifique se o servidor mitmproxy está em execução. Em seguida, execute os mesmos comandos novamente:

```none
dotnet build
dotnet run

```

O resultado deve ser semelhante a este:

```none
…output omitted…
Title: fictional bookstore, Link: http://books.toscrape.com/
Title: books.toscrape.com, Link: http://books.toscrape.com/
Title: A website, Link: http://quotes.toscrape.com/
Title: Default, Link: http://quotes.toscrape.com/
Title: Scroll, Link: http://quotes.toscrape.com/scroll
Title: JavaScript, Link: http://quotes.toscrape.com/js
Title: Delayed, Link: http://quotes.toscrape.com/js-delayed
Title: Tableful, Link: http://quotes.toscrape.com/tableful
Title: Login, Link: http://quotes.toscrape.com/login
Title: ViewState, Link: http://quotes.toscrape.com/search.aspx
Title: Random, Link: http://quotes.toscrape.com/random
…output omitted…

```

Se você verificar a janela do mitmproxy a partir do seu terminal ou shell, verá que ele interceptou a chamada:

![uma interceptação da chamada na janela do mitmproxy](https://media.brightdata.com.br/2024/02/an-interception-of-the-call-in-the-mitmproxy-window.png)Como você pode ver, configurar um proxy local ou alternar entre vários proxies pode ser uma tarefa complexa e demorada. Felizmente, ferramentas como a Bright Data podem ajudar. Na seção a seguir, você aprenderá a usar o servidor proxy da Bright Data para simplificar o processo de extração de dados.

## <a></a>Proxy da Bright Data

A Bright Data oferece uma rede [de serviços de proxy](https://brightdata.com.br/proxy-types) disponível [em 195 localizações](https://brightdata.com.br/locations). Essa rede integra o [recurso de rotação de proxies da Bright Data](https://brightdata.com.br/solutions/rotating-proxies), alternando sistematicamente entre servidores para melhorar a eficácia e a segurança do web scraping.

O uso desse sistema de proxy rotativo diminui o risco de banimentos ou bloqueios de IP normalmente enfrentados durante tarefas de web scraping. Cada solicitação usa um proxy diferente, ocultando a identidade do scraper e dificultando que os sites detectem e limitem o acesso. Essa abordagem aumenta a confiabilidade da extração de dados, garantindo maior anonimato e segurança.

A plataforma Bright Data foi projetada para facilitar o uso e simplificar a configuração, tornando-a perfeita para [projetos de web scraping em C#](https://brightdata.com.br/blog/procedimentos/web-scraping-with-c-sharp), que você verá na próxima seção.

### <a></a>Criar um proxy residencial

Antes de usar um proxy da Bright Data em seu projeto, você precisa configurar uma conta. Para fazer isso, visite o [site da Bright Data](/) e inscreva-se para um teste gratuito.

Depois de configurar sua conta, faça login e clique no ícone de localização à esquerda para navegar até **Proxies &amp; Scraping Infrastructure** (infraestrutura de proxies e scraping). Em seguida, clique em **Add** (adicionar) e escolha **[Residential Proxies](https://brightdata.com.br/proxy-types/residential-proxies) (proxies residenciais)**:

![escolhendo proxies residenciais no painel de controle  ](https://media.brightdata.com.br/2024/02/Choosing-residential-proxies-in-the-control-panel.png)Mantenha os nomes padrão e clique em **Add** novamente para criar um proxy residencial:

![criando um novo proxy residencial  ](https://media.brightdata.com.br/2024/02/creating-a-new-residential-proxy-in-the-control-panel.png)Depois de criado, você verá as credenciais do proxy, incluindo host, porta, nome de usuário e senha. Salve essas credenciais em um local seguro, pois você precisará delas mais tarde:

![credenciais de proxy que você precisa salvar  ](https://media.brightdata.com.br/2024/02/All-the-proxy-credentials.png)Navegue até seu projeto **WebScrapingBrightData** a partir do seu IDE ou terminal/shell. Em seguida, crie um arquivo de classe `BrightDataProxyConfigurator.cs` e adicione o seguinte código:

```none
using System.Net;

namespace WebScrapBrightData
{
    public class BrightDataProxyConfigurator
    {
        public static HttpClient ConfigureHttpClient(string proxyHost, string proxyUsername, string proxyPassword)
        {

            var proxy = new WebProxy(proxyHost) {
                Credentials = new NetworkCredential(proxyUsername, proxyPassword)
            };
            var httpClientHandler = new HttpClientHandler() {
                Proxy = proxy,
                UseProxy = true
            };
            var client = new HttpClient(httpClientHandler);
            client.DefaultRequestHeaders.Add("User-Agent", "YourUserAgent");
            client.DefaultRequestHeaders.Add("Accept", "application/json");

            client.DefaultRequestHeaders.TryAddWithoutValidation("Proxy-Authorization", Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{proxyUsername}:{proxyPassword}")));
            return client;

        }
    }
}

```

Nesse código, você define uma classe `BrightDataProxyConfigurator` , que inclui o método `ConfigureHttpClient` . Quando chamado, esse método configura e retorna um `HttpClient` configurado para usar um servidor proxy. Você consegue isso criando um URL de proxy usando o `nome de usuário`, `senha`, `host`e `porta `e, em seguida, configurando um `HttpClientHandler` com esse proxy. Em última análise, o método retorna uma instância `HttpClient` que encaminha todas as suas solicitações por meio do proxy especificado.

Em seguida, crie o arquivo de classe `WebContentScraper.cs` no projeto `WebScrapingBrightData` e adicione o seguinte código:

```none
using HtmlAgilityPack;

namespace WebScrapBrightData
{
    public class WebContentScraper
    {
        public static async Task ScrapeContent(string url, HttpClient client)
        {
            var response = await client.GetAsync(url);
            var content = await response.Content.ReadAsStringAsync();

            HtmlDocument doc = new();
            doc.LoadHtml(content);
            var nodes = doc.DocumentNode.SelectNodes("//li/a[@href] | //p/a[@href] | //td/a[@href]");

            if (nodes != null)
            {
                foreach (var node in nodes)
                {
                    string hrefValue = node.GetAttributeValue("href", string.Empty);
                    string title = node.InnerText;

                    Uri baseUri = new(url);
                    Uri fullUri = new(baseUri, hrefValue);

                    Console.WriteLine($"Title: {title}, Link: {fullUri.AbsoluteUri}");
                }
            }
            else
            {
                Console.WriteLine("No article links found on the page.");
            }
        }
    }
}

```

Esse código define uma classe `WebContentScraper` com um método estático assíncrono, `ScrapeContent`. Esse método usa um URL e um HttpClient, busca o conteúdo da página web, analisa-a como HTML e extrai links de elementos HTML específicos (itens de listas, parágrafos e células de tabelas). Em seguida, ele imprime os títulos e os URIs absolutos desses links no console.

#### <a></a>Classe do programa

Agora, extraia dados da Wikipedia novamente e veja como a Bright Data melhora o acesso e o anonimato.

Atualize o arquivo de classe `Program.cs` com o seguinte código:

```none
namespace WebScrapBrightData
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            // Bright Data Proxy Configuration
            string host = "your_brightdata_proxy_host";
            string username = "your_brightdata_proxy_username";
            string password = "your_brightdata_proxy_password";
            var client = BrightDataProxyConfigurator.ConfigureHttpClient(host, username, password);

            // Scrape content from the target URL
            string urlToScrape = "https://www.wikipedia.org/";
            await WebContentScraper.ScrapeContent(urlToScrape, client);
        }
    }
}

```

> **Nota:** certifique-se de substituir as credenciais de proxy da Bright Data pelas que você salvou anteriormente.

Em seguida, para testar e executar seu aplicativo, abra seu shell ou terminal a partir do diretório raiz do seu projeto `WebScrapBrightData` e execute o seguinte comando:

```none
dotnet build
dotnet run

```

Você deve obter a mesma saída de antes, quando utilizou proxies públicos:

```none
…output omitted…
Title: Latina, Link: https://la.wikipedia.org/
Title: Latviešu, Link: https://lv.wikipedia.org/
Title: Lietuvių, Link: https://lt.wikipedia.org/
Title: Magyar, Link: https://hu.wikipedia.org/
Title: Македонски, Link: https://mk.wikipedia.org/
Title: Bahasa Melayu, Link: https://ms.wikipedia.org/
Title: Bahaso Minangkabau, Link: https://min.wikipedia.org/
Title: bokmål, Link: https://no.wikipedia.org/
Title: nynorsk, Link: https://nn.wikipedia.org/
Title: Oʻzbekcha / Ўзбекча, Link: https://uz.wikipedia.org/
Title: Қазақша / Qazaqşa / قازاقشا, Link: https://kk.wikipedia.org/
Title: Română, Link: https://ro.wikipedia.org/
Title: Simple English, Link: https://simple.wikipedia.org/
Title: Slovenčina, Link: https://sk.wikipedia.org/
Title: Slovenščina, Link: https://sl.wikipedia.org/
Title: Српски / Srpski, Link: https://sr.wikipedia.org/
Title: Srpskohrvatski / Српскохрватски, Link: https://sh.wikipedia.org/
Title: Suomi, Link: https://fi.wikipedia.org/
Title: தமிழ், Link: https://ta.wikipedia.org/
…output omitted…

```

O programa usa o proxy Bright Data para extrair dados da página inicial da Wikipedia e exibir no console os títulos e links extraídos. Isso mostra a eficácia e a facilidade de integrar o proxy Bright Data em um projeto de web scraping em C# para uma extração de dados discreta e robusta.

Se você quiser visualizar o efeito do uso de um proxy da Bright Data, tente enviar uma solicitação GET para <http://lumtest.com/myip.json>. Esse site retornará a localização e outros detalhes relacionados à rede do cliente que está tentando acessar o site no momento. Se você quiser tentar fazer isso sozinho, abra o link em uma nova guia do navegador. Você deve ver os detalhes da sua rede que são visíveis publicamente.

Para testar com um proxy da Bright Data, atualize o código em `WebContentScraper.cs` para corresponder ao seguinte:

```none
using HtmlAgilityPack;

public class WebContentScraper
{
    public static async Task ScrapeContent(string url, HttpClient client)
    {
        var response = await client.GetAsync(url);
        var content = await response.Content.ReadAsStringAsync();

        HtmlDocument doc = new();
        doc.LoadHtml(content);

        Console.Write(content);
    }
}

```

Em seguida, atualize a variável `URLToScrape` no arquivo `Program.cs` para extrair dados do site:

```none
            string urlToScrape = "http://lumtest.com/myip.json";

```

Agora, tente executar o aplicativo novamente. Você deve ver no terminal um resultado parecido com este:

```none
{"ip":"79.221.123.68","country":"DE","asn":{"asnum":3320,"org_name":"Deutsche Telekom AG"},"geo":{"city":"Koenigs Wusterhausen","region":"BB","region_name":"Brandenburg","postal_code":"15711","latitude":52.3014,"longitude":13.633,"tz":"Europe/Berlin","lum_city":"koenigswusterhausen","lum_region":"bb"}}

```

Isso confirma que a solicitação está agora passando pelos servidores proxy da Bright Data.

## <a></a>Conclusão

Neste artigo, você aprendeu como usar servidores proxy com C# para web scraping.

Embora os servidores proxy locais possam ser úteis em alguns cenários, eles geralmente apresentam limitações para projetos de web scraping. Felizmente, [servidores proxy](https://brightdata.com.br/proxy-types/proxy-servers) podem ajudar. Com sua extensa rede global e uma ampla variedade de opções de proxy, incluindo proxies [residenciais](https://brightdata.com.br/proxy-types/residential-proxies), de [ ISPs](https://brightdata.com.br/proxy-types/isp-proxies), de [datacenters](https://brightdata.com.br/proxy-types/datacenter-proxies) e [móveis](https://brightdata.com.br/proxy-types), a Bright Data garante um alto grau de flexibilidade e confiabilidade. Notavelmente, o recurso de rotação de proxies é inestimável para tarefas de extração de dados em grande escala, ajudando a manter o anonimato e reduzir o risco de banimentos de IP.

Ao continuar sua jornada de web scraping, considere usar as soluções da Bright Data como uma forma poderosa e escalável de coletar dados com eficiência e, ao mesmo tempo, seguir as melhores práticas de extração de dados da web.

Todo o código deste tutorial está disponível [neste repositório do GitHub](https://github.com/luminati-io/proxy-csharp).



Contate-nosTeste grátis![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg)









 Índice







Dedicated Scraper APIs &amp; No-Code Scrapers

Over 1000 scrapers for all popular domains. Simplify your web scraping.

[See pricing](/pricing/web-scraper "See pricing")

Just want data? Skip scraping.

Hundreds of ready-to-use datasets from all popular domains.

[See pricing](/pricing/datasets "See pricing")







 [ ](https://news.ycombinator.com/submitlink?t=Como+configurar+servidores+proxy+em+C%23&u=https://brightdata.com.br/blog/procedimentos/proxy-with-c-sharp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Como+configurar+servidores+proxy+em+C%23&url=https://brightdata.com.br/blog/procedimentos/proxy-with-c-sharp) [ ](http://www.reddit.com/submit?title=Como+configurar+servidores+proxy+em+C%23&url=https://brightdata.com.br/blog/procedimentos/proxy-with-c-sharp)







##  Você também pode estar interessado em

 [ ![Datacenter Proxies vs. Residential Proxies](https://media.brightdata.com.br/2022/08/Datacenter-Proxies-vs.-Residential-Proxies.png) ](https://brightdata.com.br/blog/proxies-101/differences-between-datacenter-and-residential-proxies "Proxies de datacenter vs. proxies residenciais: uma comparação aprofundada")

 [Proxy 101



 ![Daniel Shashko](https://media.brightdata.com.br/2022/04/Daniel-Shashko-2-50x50.png)

Daniel Shashko

Web Data &amp; AI Expert





### Proxies de datacenter vs. proxies residenciais: uma comparação aprofundada

“Qual é a velocidade dos IPs?”; “Qual é a eficácia deles em contornar bloqueios de sites de destino?”; “Qual é o grau de exclusividade dos IPs?”; “Quantos locais estão disponíveis?”; “Qual é o custo para o usuário final?” – Todas as suas perguntas respondidas.



 25-Feb-2026

 7 min de leitura

 ](https://brightdata.com.br/blog/proxies-101/differences-between-datacenter-and-residential-proxies)

 [ ![C# vs Python scraping](https://media.brightdata.com.br/2023/12/How-to-Scrape-Zalando-1.svg) ](https://brightdata.com.br/blog/procedimentos/c-sharp-vs-python-for-web-scraping "C# vs. Python para guia de Scraping de dados")

 [procedimentos





Mdu Sibisi

Tech Writer





### C# vs. Python para guia de Scraping de dados

Explore o Guia de Scraping de Dados C# vs. Python para aproveitar o desempenho do C# e a simplicidade do Python. Descubra os pontos fortes de cada linguagem para obter resultados ideais em seus projetos de Scraping de Dados.



 22-Feb-2026

 14 min de leitura

 ](https://brightdata.com.br/blog/procedimentos/c-sharp-vs-python-for-web-scraping)

 [ ![Person coding on laptop with browser and icons.](https://media.brightdata.com.br/2023/01/Web-scraping-with-C.png) ](https://brightdata.com.br/blog/procedimentos/web-scraping-with-c-sharp "O guia definitivo de raspagem da web com C#")

 [procedimentos









### O guia definitivo de raspagem da web com C#

Neste tutorial, você aprenderá como construir um raspador da web em C#. Em pormenor, verá como efetuar um pedido HTTP para descarregar a página web que pretende raspar, selecionar elementos HTML da sua árvore do DOM e extrair dados dos mesmos.



 08-Jan-2023

 18 min de leitura

 ](https://brightdata.com.br/blog/procedimentos/web-scraping-with-c-sharp)