[Blog](https://scrapfly.io/blog) / [frameworks](https://scrapfly.io/blog/tag/frameworks) / [How to Use a Proxy With C# HttpClient in 2026](https://scrapfly.io/blog/posts/csharp-httpclient-proxy) # How to Use a Proxy With C# HttpClient in 2026 by [Mayada Shaaban](https://scrapfly.io/blog/author/mayada-shaaban-90143e67) Oct 16, 2026 13 min read [\#frameworks](https://scrapfly.io/blog/tag/frameworks) [\#http](https://scrapfly.io/blog/tag/http) [\#proxies](https://scrapfly.io/blog/tag/proxies) [ ](https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy "Share on LinkedIn") [ ](https://x.com/intent/tweet?url=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy&text=How%20to%20Use%20a%20Proxy%20With%20C%23%20HttpClient%20in%202026 "Share on X") [ ](https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy "Share on Facebook") Summarize this article with [ ](https://chat.openai.com/?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy) [ ](https://claude.ai/new?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy) [ ](https://x.com/i/grok?text=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy) [ ](https://www.perplexity.ai/search/new?q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy) [ ](https://www.google.com/search?udm=50&aep=11&q=Summarize%20this%20article%20and%20explain%20how%20Scrapfly%20helps%20me%20scrape%20any%20website%20at%20scale%20and%20bypass%20anti-bot%20systems%20for%20my%20use%20case%3A%20https%3A%2F%2Fscrapfly.io%2Fblog%2Fposts%2Fcsharp-httpclient-proxy) Most C# proxy examples show one working request and stop there. Add a second proxy and the connection pool starts churning. Credentials produce a 407 you can't explain, or the target blocks you anyway since the IP was only one signal. This guide builds the patterns that hold up past the first request. It covers authenticated proxies and a rotation pool, with the five common 407 causes each mapped to a fix. It also covers what proxy code alone can't do, JavaScript and fingerprinting. [Comprehensive Guide to OkHttp for Java and KotlinLearn how to simplify network communication in Java and Android applications using OkHttp.](https://scrapfly.io/blog/posts/guide-to-okhttp-java-kotlin) ## Key Takeaways - **Configure the proxy on the handler** (`SocketsHttpHandler` or `HttpClientHandler`) before you create `HttpClient`. - **Pair `WebProxy` with `NetworkCredential`** for an authenticated HTTP proxy. - **Reuse one client and handler per proxy** instead of rebuilding the stack per request. - **Pool one client per gateway** when rotation needs distinct proxy endpoints. - **A 407 comes from the proxy**: it rejected your proxy credentials or never received them. - **`SocketsHttpHandler` supports SOCKS5** through a `socks5://` URI since .NET 6. - **A proxy only changes routing.** JavaScript rendering and browser fingerprinting need a browser or a managed API. **Get web scraping tips in your inbox**Trusted by 100K+ developers and 30K+ enterprises. Unsubscribe anytime. ## How Does HttpClient Proxy Configuration Work in .NET? `HttpClient` sends every request through whatever proxy sits on its underlying handler, so the proxy belongs to the handler's lifecycle rather than any single request. Changing the proxy means replacing the handler, not tweaking a request option. Two handlers carry the `Proxy` property: `HttpClientHandler` and `SocketsHttpHandler`, .NET's current default transport. Both accept an `IWebProxy` implementation, .NET's interface for a [proxy server](https://scrapfly.io/blog/posts/what-is-a-proxy-server). Almost always that's `WebProxy`, the concrete class holding a proxy address, an optional bypass list, and credentials. The handler also owns connection pooling. Every `HttpClient` built on the same handler instance shares its connection pool, which is why proxy identity lives on the handler. Swap `handler.Proxy` on a handler that's already sent a request and .NET throws: text ```text InvalidOperationException: This instance has already started one or more requests. Properties can only be modified before sending the first request. ``` That exception is the reason a rotation strategy needs one handler per proxy, instead of one handler mutated in place. One more distinction matters before any code. An HTTP proxy for an HTTPS target doesn't decrypt anything. The client sends an HTTP `CONNECT` request to open a tunnel. TLS then negotiates straight through to the target. The proxy only ever sees the destination host and port, never the encrypted request or response body. ## How Do You Configure an Authenticated Proxy With SocketsHttpHandler? Set `Proxy` and `Credentials` on a `SocketsHttpHandler` before the first request goes out, and every request from the resulting `HttpClient` routes through that proxy. Drop this into a `dotnet new console` project, with the proxy values read from environment variables: csharp ```csharp using System.Net; var proxy = new WebProxy(RequiredEnv("PROXY_URL")) { Credentials = new NetworkCredential( RequiredEnv("PROXY_USERNAME"), RequiredEnv("PROXY_PASSWORD")) }; using var handler = new SocketsHttpHandler { Proxy = proxy, UseProxy = true, ConnectTimeout = TimeSpan.FromSeconds(10) }; using var client = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(30) }; client.DefaultRequestHeaders.UserAgent.ParseAdd("MyScraperApp/1.0"); var response = await client.GetAsync("https://httpbin.org/ip"); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync()); static string RequiredEnv(string name) => Environment.GetEnvironmentVariable(name) ?? throw new InvalidOperationException($"Missing {name}"); ``` Run against a live proxy, this prints the exit IP the target saw: json ```json { "origin": "203.0.113.42" } ``` `RequiredEnv` throws right away if a proxy variable is missing, instead of sending an unauthenticated request that fails downstream with a confusing error. Keeping credentials out of source is a hard requirement here. Anyone who clones the repository also clones a proxy password checked into it. `https://httpbin.org/ip` is a safe route check for exactly this reason. It returns only the caller's IP. Confirm the proxy is live with it before pointing the same client at a real target. `UseProxy` defaults to `true`, but setting it explicitly next to `Proxy` keeps the handler's intent readable, especially once a codebase has more than one handler in play. Before calling `EnsureSuccessStatusCode`, inspect `response.StatusCode` directly while debugging. It tells you whether a non-200 came from the proxy or from the target, which matters for the 407 section coming up. ## Can You Use HttpClientHandler Instead? Yes. `HttpClientHandler.Proxy` accepts the same `IWebProxy` instance and is the simpler, longer-standing public surface for applications that don't need `SocketsHttpHandler`'s lower-level connection controls. The snippet below replaces the handler in the previous program and reuses its `using System.Net;` line and `RequiredEnv` helper. csharp ```csharp var proxy = new WebProxy(RequiredEnv("PROXY_URL")) { Credentials = new NetworkCredential( RequiredEnv("PROXY_USERNAME"), RequiredEnv("PROXY_PASSWORD")) }; using var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true }; using var client = new HttpClient(handler); ``` The same lifecycle rule from the previous section still applies. Set `Proxy`before the first request, and treat the handler, not the client, as the object that owns the proxy. `HttpClientHandler` and `SocketsHttpHandler` share the proxy configuration surface, so nothing here changes based on which one a codebase already uses. This guide sticks to current .NET APIs throughout. Legacy `WebRequest` patterns from older .NET Framework code aren't part of that surface and won't show up here. Neither handler is universally faster without measuring your own workload. Pick `SocketsHttpHandler` for pooling and timeout tuning. Pick `HttpClientHandler` when its defaults are enough. ## How Do You Rotate Proxies Without Recreating HttpClient Per Request? Build a small, reusable pool of clients, one `SocketsHttpHandler` and `HttpClient` per stable proxy, and hand out a client per request with a round-robin counter. Rebuilding the handler stack on every request throws away connection pooling and adds TLS handshake overhead to every single call. csharp ```csharp using System.Net; using System.Threading; sealed class ProxyClientPool : IDisposable { private readonly HttpClient[] _clients; private readonly SocketsHttpHandler[] _handlers; private int _index = -1; public ProxyClientPool((string proxyUrl, string user, string pass)[] gateways) { _handlers = new SocketsHttpHandler[gateways.Length]; _clients = new HttpClient[gateways.Length]; for (int i = 0; i < gateways.Length; i++) { var (proxyUrl, user, pass) = gateways[i]; var proxy = new WebProxy(proxyUrl) { Credentials = new NetworkCredential(user, pass) }; _handlers[i] = new SocketsHttpHandler { Proxy = proxy, UseProxy = true, ConnectTimeout = TimeSpan.FromSeconds(10) }; _clients[i] = new HttpClient(_handlers[i]) { Timeout = TimeSpan.FromSeconds(30) }; } } public HttpClient GetClient() { var next = Interlocked.Increment(ref _index); var slot = (int)((uint)next % _clients.Length); return _clients[slot]; } public void Dispose() { foreach (var client in _clients) client.Dispose(); foreach (var handler in _handlers) handler.Dispose(); } } ``` `Interlocked.Increment` keeps the round-robin counter safe across concurrent callers without a lock. Each gateway gets its own handler built once at startup, since mutating a live handler's `Proxy` throws the `InvalidOperationException` from the earlier section. `Dispose` tears down every client and handler together at application shutdown. [Best Proxy Providers for Web Scraping: Choose by Type (2026)Compare datacenter, residential, ISP, and mobile proxies by decision gate, then choose direct inventory, managed fetching, or an egress optimizer.](https://scrapfly.io/blog/posts/best-proxy-providers-for-web-scraping) Not every rotation problem needs this pool. A backconnect gateway rotates the upstream IP behind a single proxy address on the provider's side. Over HTTPS, the exit IP is fixed for the life of each `CONNECT` tunnel, and `HttpClient` reuses one tunnel across requests. Set `PooledConnectionLifetime = TimeSpan.Zero` on the handler when the gateway should assign a new IP per request, at the cost of a new tunnel and TLS handshake each time. Check whether your provider already does this before building application-level rotation on top of it. Scrapfly #### Scale your web scraping effortlessly Scrapfly handles proxies, browsers, and anti-bot bypass — so you can focus on data. [Try Free →](https://scrapfly.io/register)## Why Does C# HttpClient Return 407 Proxy Authentication Required? A 407 means the proxy itself rejected or never received acceptable credentials. It comes from the proxy, not from the target site, and that distinction is the fastest way to narrow down the fix. For an HTTPS target, `SocketsHttpHandler` surfaces the failure as an `HttpRequestException` with `StatusCode` set to `ProxyAuthenticationRequired`: text ```text HttpRequestException: The proxy tunnel request to proxy 'http://proxy.myprovider.com:8000/' failed with status code '407'." ``` That trailing quote after the period is a real quirk in the framework's own error string, not a typo here. An `http://` target needs no tunnel, so its 407 arrives as an ordinary response, and nothing throws until `EnsureSuccessStatusCode` runs. Five failure modes account for most 407 responses in C# code: - **Missing credentials:** `WebProxy.Credentials` was never set, so the handler sends the `CONNECT` request with no `Proxy-Authorization` header. - **Wrong credential format:** the username, password, or a provider-specific zone suffix has a typo or got truncated somewhere. - **Credentials sent to the target instead:** setting an `Authorization`header on `DefaultRequestHeaders` authenticates you to the target, not to the proxy. Proxy auth only ever comes from `WebProxy.Credentials`. - **Proxy protocol mismatch:** the URI scheme or port in `PROXY_URL` doesn't match what the gateway expects. - **Stale client configuration:** a reused handler still points at a proxy from an earlier session, because the fix in the earlier section, one handler per proxy, wasn't followed. Log the status and the proxy host, never the credentials themselves: csharp ```csharp catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.ProxyAuthenticationRequired) { Console.WriteLine($"Proxy rejected the request: {ex.StatusCode}"); Console.WriteLine($"Proxy host: {proxy.Address}"); } ``` `proxy.Address` gives you the host and port to check against `PROXY_URL`without ever touching `proxy.Credentials` in a log line. ## What Can a Proxy Not Fix in a C# Scraper? A proxy changes the network path a request takes. It doesn't render JavaScript, reproduce a real browser's behavior, or guarantee the target returns anything usable back: - **JavaScript-rendered pages** come back as near-empty HTML, since `HttpClient` never executes the scripts that build the page content. - **Cookie and session flows** need explicit handling. `HttpClient` won't replay a login or a multi-step checkout for you. - **Browser fingerprint and TLS differences** stay visible however clean the IP is. A .NET TLS handshake doesn't look like Chrome's, and a detection system that checks the handshake sees straight through the proxy. - **Challenge pages** commonly return HTTP 200 with a CAPTCHA or an interstitial in the body, not a 403 you can catch in a status check. Check the body before you trust a 200: csharp ```csharp var response = await client.GetAsync(url); var body = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode && !body.Contains("expected-marker")) { throw new InvalidOperationException("Got HTTP 200 but not the expected content."); } ``` Asserting on a marker you expect in the real page catches a challenge page that a status-code check alone would wave through. ## When Should a C# Scraper Use Scrapfly Instead of Raw Proxy Rotation? Raw proxy rotation is a reasonable choice while a target stays simple and your team already owns health checks, retries, and rotation logic. Once a target renders through JavaScript or sits behind an anti-bot system, that ownership gets expensive fast. At that point you also need a browser to render the page and a TLS handshake that passes fingerprint checks, and a proxy pool provides neither. For those targets, skip proxy management and call the scrape API straight from `HttpClient`. There's no official C# SDK, so a plain GET request is the current path: csharp ```csharp var apiKey = Environment.GetEnvironmentVariable("SCRAPFLY_API_KEY") ?? throw new InvalidOperationException("Missing SCRAPFLY_API_KEY"); // Scrapfly's docs set the client read timeout to 155 s using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(155) }; var url = "https://api.scrapfly.io/scrape" + "?key=" + apiKey + "&url=" + Uri.EscapeDataString("https://web-scraping.dev/product/1") + "&unblocker=true"; var response = await client.GetAsync(url); response.EnsureSuccessStatusCode(); Console.WriteLine(await response.Content.ReadAsStringAsync()); ``` `unblocker=true` (previously `asp=true`) hands anti-bot handling to the API instead of a hand-rolled proxy pool. The response carries the scrape result and metadata as JSON, so the same `HttpClient` you've been using throughout this guide is the only client needed. ScrapFly's [Web Scraping API](https://scrapfly.io/products/web-scraping-api) is a single HTTP endpoint for collecting web data at scale, with a **98% success rate** on the hardest public pages and proxies across **190+ countries**. - [Web Unblocker API](https://scrapfly.io/products/unblocker) (previously ASP) - automatically defeats 25+ anti-bot systems, including Cloudflare, DataDome, PerimeterX and Akamai. - [Smart proxy rotation](https://scrapfly.io/docs/scrape-api/proxy) - residential and datacenter pools with country-level geo-targeting. - [JavaScript rendering](https://scrapfly.io/docs/scrape-api/javascript-rendering) - render SPAs and dynamic pages through real cloud browsers. - [Browser automation scenarios](https://scrapfly.io/docs/scrape-api/javascript-scenario) - scroll, click, fill forms, and wait for elements without managing a browser fleet. - [Format conversion](https://scrapfly.io/docs/scrape-api/getting-started#api_param_format) - return pages as HTML, JSON, clean text, or LLM ready Markdown. - [Session management](https://scrapfly.io/docs/scrape-api/session) - keep cookies, headers, and IPs consistent across multi step flows. - [Smart caching](https://scrapfly.io/docs/scrape-api/getting-started#api_param_cache) - cache successful responses to cut cost on repeat scraping jobs. - [Python](https://scrapfly.io/docs/sdk/python), [TypeScript](https://scrapfly.io/docs/sdk/typescript), [Go](https://scrapfly.io/docs/sdk/golang), and [Rust](https://scrapfly.io/docs/sdk/rust) SDKs, plus [no-code integrations](https://scrapfly.io/docs/integration/getting-started) including [Make](https://scrapfly.io/integration/make), [n8n](https://scrapfly.io/integration/n8n), [Zapier](https://scrapfly.io/integration/zapier), [LangChain](https://scrapfly.io/integration/langchain), and [LlamaIndex](https://scrapfly.io/integration/llamaindex). For the raw `HttpClient` calls this guide has been building, that endpoint slots in wherever a target needs more than IP rotation. No proxy pool, credential rotation, or JavaScript renderer stays on your end to maintain. ### Web Scraping API Scrape any website with our powerful API. Anti-bot bypass, JavaScript rendering, and rotating proxies built-in. [Try Web Scraping API](https://scrapfly.io/docs/scrape-api/getting-started) ## FAQ Does HttpClient support SOCKS5 proxies?Yes. `SocketsHttpHandler` has supported SOCKS4, SOCKS4a, and SOCKS5 natively since .NET 6. Point `WebProxy` at a `socks5://host:port` URI and set `NetworkCredential` the same way as for an HTTP proxy. Should you create a new HttpClient for every proxy request?No. Reuse one client and handler for a stable proxy, and rotate across a bounded `ProxyClientPool` only when each proxy needs its own handler. What is the difference between 401 and 407 in a proxy workflow?A [401](https://scrapfly.io/blog/posts/what-is-http-401-error-and-how-to-fix-it) comes from the target origin's own authentication layer. A 407 comes from the proxy and concerns proxy authentication only. How do you verify that HttpClient used the proxy?Request a safe IP echo endpoint like `https://httpbin.org/ip` and compare the returned address against the proxy's known exit IP. Never log the proxy credentials while doing it. Is it legal to scrape with a proxy in C#?Scraping publicly available data is generally legal. A proxy doesn't change a target's terms of service or the legal status of the data itself. Review both before building a scraper against a specific site. ## Summary `HttpClient` takes its proxy from the handler. `SocketsHttpHandler.Proxy` and `WebProxy.Credentials` come before `HttpClient` in every pattern here. Reuse a client per proxy, and pool one per gateway for rotation. Read `HttpRequestException.StatusCode` before assuming a 407 is a target-side problem. A 200 status only proves the server answered, so check the body for a marker you expect. Raw rotation stays fine for simple targets your team already maintains. For anything JavaScript-rendered or protected, Scrapfly's managed API takes over the proxy pool, rendering, and anti-bot handling. It works behind the same `HttpClient` calls you already wrote. Legal Disclaimer and PrecautionsThis tutorial covers popular web scraping techniques for education. Interacting with public servers requires diligence and respect: - Do not scrape at rates that could damage the website. - Do not scrape data that's not available publicly. - Do not store PII of EU citizens protected by GDPR. - Do not repurpose *entire* public datasets which can be illegal in some countries. Scrapfly does not offer legal advice but these are good general rules to follow. For more you should consult a lawyer. [ Add as a preferred source ](https://google.com/preferences/source?q=scrapfly.io) Table of Contents Table of Contents - [Key Takeaways](#key-takeaways) - [How Does HttpClient Proxy Configuration Work in .NET?](#how-does-httpclient-proxy-configuration-work-in-net) - [How Do You Configure an Authenticated Proxy With SocketsHttpHandler?](#how-do-you-configure-an-authenticated-proxy-with-socketshttphandler) - [Can You Use HttpClientHandler Instead?](#can-you-use-httpclienthandler-instead) - [How Do You Rotate Proxies Without Recreating HttpClient Per Request?](#how-do-you-rotate-proxies-without-recreating-httpclient-per-request) - [Why Does C# HttpClient Return 407 Proxy Authentication Required?](#why-does-c-httpclient-return-407-proxy-authentication-required) - [What Can a Proxy Not Fix in a C# Scraper?](#what-can-a-proxy-not-fix-in-a-c-scraper) - [When Should a C# Scraper Use Scrapfly Instead of Raw Proxy Rotation?](#when-should-a-c-scraper-use-scrapfly-instead-of-raw-proxy-rotation) - [FAQ](#faq) - [Summary](#summary) Join the Newsletter Get monthly web scraping insights Scale Your Web Scraping Anti-bot bypass, browser rendering, and rotating proxies, all in one API. Start with 1,000 free credits. No credit card required 1,000 free API credits Anti-bot bypass included [Start Free](https://scrapfly.io/register) [View Docs](https://scrapfly.io/docs/onboarding) Not ready? Get our newsletter instead. ## Related Articles [ http ### What is HTTP 407 Status Code and How to Fix it Imagine trying to access a website, only to be stopped in your tracks by a frustrating error code. If you've encountered... ](https://scrapfly.io/blog/posts/what-is-http-407-status-code-and-how-to-fix-it) [ python proxies ### How to Rotate Proxies in Web Scraping In this article we explore proxy rotation. How does it affect web scraping success and blocking rates and how can we sma... ](https://scrapfly.io/blog/posts/how-to-rotate-proxies-in-web-scraping) [ blocking proxies ### The Complete Guide To Using Proxies For Web Scraping Introduction to proxy usage in web scraping. What types of proxies are there? How to evaluate proxy providers and avoid ... ](https://scrapfly.io/blog/posts/introduction-to-proxies-in-web-scraping) ## Related Questions - [ Q How to configure Python requests to use a proxy? ](https://scrapfly.io/blog/answers/python-requests-proxy-intro) - [ Q How to Rotate Proxies in Scrapy ](https://scrapfly.io/blog/answers/scrapy-spiders-proxy-rotation) - [ Q What is The cURL (28) Error, Couldn't connect to server? ](https://scrapfly.io/blog/answers/what-is-the-curl-28-error) - [ Q How to use proxies with Python httpx? ](https://scrapfly.io/blog/answers/how-to-use-proxies-python-httpx) Premium rotating proxies for scraping, **1,000 free credits** [Start Free](https://scrapfly.io/register)