Your .NET side project works perfectly on your laptop. You ship it. Traffic picks up. Then the errors start. Socket errors, random timeouts, and sluggish responses that make no sense. The culprit is almost always how you create and manage HttpClient. This is one of the most quietly destructive patterns in .NET development, and most indie developers only discover it the hard way.

This article skips the theory and focuses on what you actually need to change. Whether you're running a small API, a scraper, or a webhook processor, these fixes apply directly to your workflow.

The Hidden Cost of "Simple" HTTP Calls

Every time your app calls an external API, it opens a network connection. That connection uses a local port on your machine. Your operating system has a limited pool of these ports, typically in the range of a few thousand usable at any moment for a given destination.

When a connection closes, it doesn't free its port instantly. The OS holds it in a waiting state for a period of time. Under moderate load, this is fine. Under real traffic, this becomes a port exhaustion problem where your app literally runs out of available ports to open new connections.

Here's the pattern that triggers this most often in solo dev projects:

// Do NOT do this
public async Task<string> FetchDataAsync(string url)
{
    using var client = new HttpClient();
    return await client.GetStringAsync(url);
}

Every call constructs a fresh HttpClient, which builds a fresh connection handler underneath it. Connection pooling is bypassed completely. Under any real load, this pattern hammers your socket table and causes exactly the cryptic errors that send developers to Stack Overflow for hours.

Why a Static HttpClient Isn't the Full Answer

The common fix people reach for first is making HttpClient a static singleton. It's better than creating one per call. However, it introduces a different problem that bites long-running processes.

A static HttpClient holds onto its DNS resolution. If the IP address behind an API hostname changes, your app keeps sending requests to the old address. This is a real failure mode for apps that run continuously, like background workers or bots.

Furthermore, a single static instance gives you no clean way to configure different settings for different APIs. Your GitHub client, your payment processor client, and your notification service client all need different base addresses, headers, and timeouts. Cramming that into one object gets messy fast.

IHttpClientFactory: What It Actually Does for You

IHttpClientFactory is the proper solution for most .NET apps. It's part of the Microsoft.Extensions.Http package and integrates directly into the ASP.NET Core dependency injection system. Understanding what it does under the hood helps you use it correctly.

The factory pools the underlying connection handlers, not the HttpClient objects themselves. It cycles those handlers on a schedule, which means DNS changes get picked up automatically. You get connection reuse without the stale DNS problem.

HttpClient Best Practices

🔧

Use IHttpClientFactory
Manage HttpClient instances effectively.

🚫

Avoid Per-Call Clients
Prevent port exhaustion by reusing clients.

⏳

Control Handler Lifetime
Optimize connection pooling and performance.

⚡

Implement Async Calls
Use async for non-blocking operations.

📊

Monitor Socket Usage
Keep track of open and closed connections.

Setting Up Named Clients

Named clients let you configure distinct HTTP clients for each external service your app talks to. Register them once in your startup code and inject the factory wherever you need it.

// Program.cs
builder.Services.AddHttpClient("Stripe", client =>
{
    client.BaseAddress = new Uri("https://api.stripe.com/v1/");
    client.DefaultRequestHeaders.Add("Authorization", "Bearer " + stripeKey);
    client.Timeout = TimeSpan.FromSeconds(10);
});

builder.Services.AddHttpClient("SendGrid", client =>
{
    client.BaseAddress = new Uri("https://api.sendgrid.com/v3/");
    client.Timeout = TimeSpan.FromSeconds(15);
});

Each named client gets its own handler pool. You can now call Stripe and SendGrid with properly isolated, pooled connections. No more socket pressure from repeated client construction.

Typed Clients for Cleaner Architecture

For larger projects, typed clients are even cleaner. You create a service class that takes an HttpClient in its constructor. The DI system wires it up automatically. Your business logic never needs to know about named strings or factory calls directly.

public class StripeService
{
    private readonly HttpClient _client;

    public StripeService(HttpClient client)
    {
        _client = client;
    }

    public async Task<string> GetCustomerAsync(string id, CancellationToken ct)
    {
        return await _client.GetStringAsync($"customers/{id}", ct);
    }
}

// Program.cs
builder.Services.AddHttpClient<StripeService>(client =>
{
    client.BaseAddress = new Uri("https://api.stripe.com/v1/");
});

This approach makes testing straightforward. You can inject a mock or a test handler without touching your business logic. For indie developers who want to move fast without breaking things, this pattern pays off quickly.

Threading Problems You Might Be Ignoring

Port exhaustion gets most of the attention, but thread pool pressure from poorly written async code causes equally serious problems. The .NET thread pool has a fixed number of threads. Blocking a thread while waiting for a network response wastes one of those slots.

Under load, blocking threads cause a backlog. New requests queue up waiting for a thread. Response times spike. The app feels slow even though CPU and memory look fine in your monitoring dashboard.

The rule is simple: never call .Result or .Wait() on an async HTTP operation. Use await all the way through. This releases the thread while the network does its work, and the thread pool stays healthy.

Additionally, always pass a CancellationToken through your HTTP calls. Without one, a stalled external API can hold a thread indefinitely. Set sensible timeouts and propagate cancellation tokens from your controllers or background services down to every HTTP call.

Security Basics You Shouldn't Skip

While you're auditing your HTTP client setup, take a moment to check your security posture. Outbound HTTP calls to external APIs are a real attack surface. Poorly configured clients can leak credentials or connect to unintended endpoints.

Review the OWASP Top Ten if you haven't recently. Several of the top vulnerabilities relate directly to how apps handle HTTP connections and credentials. It's a short read with direct applicability to indie projects.

Also consider your development environment security. If you're working from coffee shops or shared networks, a comprehensive VPN guide can help you understand how to protect your API keys and credentials while testing against live services.

For credential exposure specifically, check whether any of your development accounts have been compromised using Have I Been Pwned. It's a habit worth building before a breach affects a paying user.

Practical Checklist Before You Ship

Here's a quick audit list for any .NET project that makes outbound HTTP calls. Run through this before your next deployment.

No new HttpClient per request, check every service class for the anti-pattern
IHttpClientFactory registered, confirm it's in your DI setup via AddHttpClient
Named or typed clients per API, each external service gets its own named registration
Timeouts configured, never leave the default unlimited timeout in production
Await used consistently, search for .Result and .Wait() calls and replace them
CancellationTokens passed through, from controller actions down to every HTTP call
Credentials in environment variables, not hardcoded in client configuration

This list takes about twenty minutes to work through. It will save you hours of debugging under production load.

Avoiding HttpClient Pitfalls

Identify Problem

Recognize symptoms like timeouts and errors.

Refactor Code

Change to use IHttpClientFactory.

Test Under Load

Simulate traffic to validate performance.

Monitor Performance

Use tools to track HTTP performance.

Measuring the Impact on Your App's Performance

How do you know if these changes actually helped? You need baseline measurements before and after. Response time percentiles are more informative than averages here. A mean response time can look healthy while your 95th percentile is terrible.

Use a percentile calculator to analyze response time data you pull from your logs. Compare your p50, p95, and p99 before and after switching to IHttpClientFactory. The difference at the high end is where you'll see the real improvement.

Beyond raw performance numbers, check your web presence holistically. If your app has a public-facing component, use a free website grader to identify performance and SEO issues that might be affecting your visibility. Slow apps rank lower and convert worse.

Meanwhile, if you're distributing your .NET tools or libraries publicly, your documentation and licensing matter. Resources like Creative Commons can help you choose the right license for shared code examples and guides you publish alongside your projects.

Tools That Complement Good HTTP Client Hygiene

Getting your HttpClient setup right is foundational. However, it's one piece of a larger operational picture for solo developers running production apps.

If you're building anything with a customer-facing component, your social presence matters for discovery. Run a free social media audit tool to check how your profiles appear to potential users. A solid product with weak social signals gets overlooked.

For developers who track metrics across different systems or international APIs, unit conversions come up more than you'd expect. A quick measurement converter tool handles those conversions without breaking your focus.

If you're monetizing your project through an online store, Shopify integrates well with .NET backends and handles the payment infrastructure so you can stay focused on your core product.

What to Fix First

If you only make one change today, eliminate the per-request HttpClient construction pattern from your codebase. That single fix prevents the most common production failure mode for .NET apps making outbound HTTP calls.

After that, add IHttpClientFactory with named registrations for each external service you call. Configure timeouts. Pass cancellation tokens. These changes compound. They make your app more stable, easier to test, and simpler to debug when something does go wrong.

Are you already using IHttpClientFactory in your projects? Or did you find the per-request pattern lurking in your codebase? Either way, run the checklist above and see what you find. The fixes are small. The production stability gains are significant.

This post contains affiliate links. If you make a purchase through these links, we may earn a commission at no additional cost to you.