This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Important

This information relates to a pre-release product that may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

For the current release, see the .NET 8 version of this article .

By Kirk Larkin , Steve Gordon , Glenn Condron , and Ryan Nowak .

An IHttpClientFactory can be registered and used to configure and create HttpClient instances in an app. IHttpClientFactory offers the following benefits:

The sample code in this topic version uses System.Text.Json to deserialize JSON content returned in HTTP responses. For samples that use Json.NET and ReadAsAsync<T> , use the version selector to select a 2.x version of this topic.

Consumption patterns

There are several ways IHttpClientFactory can be used in an app:

The best approach depends upon the app's requirements.

Basic usage

Register IHttpClientFactory by calling AddHttpClient in Program.cs :

var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddHttpClient();
An IHttpClientFactory can be requested using dependency injection (DI). The following code uses IHttpClientFactory to create an HttpClient instance:
public class BasicModel : PageModel
    private readonly IHttpClientFactory _httpClientFactory;
    public BasicModel(IHttpClientFactory httpClientFactory) =>
        _httpClientFactory = httpClientFactory;
    public IEnumerable<GitHubBranch>? GitHubBranches { get; set; }
    public async Task OnGet()
        var httpRequestMessage = new HttpRequestMessage(
            HttpMethod.Get,
            "https://api.github.com/repos/dotnet/AspNetCore.Docs/branches")
            Headers =
                { HeaderNames.Accept, "application/vnd.github.v3+json" },
                { HeaderNames.UserAgent, "HttpRequestsSample" }
        var httpClient = _httpClientFactory.CreateClient();
        var httpResponseMessage = await httpClient.SendAsync(httpRequestMessage);
        if (httpResponseMessage.IsSuccessStatusCode)
            using var contentStream =
                await httpResponseMessage.Content.ReadAsStreamAsync();
            GitHubBranches = await JsonSerializer.DeserializeAsync
                <IEnumerable<GitHubBranch>>(contentStream);
Using IHttpClientFactory like in the preceding example is a good way to refactor an existing app. It has no impact on how HttpClient is used. In places where HttpClient instances are created in an existing app, replace those occurrences with calls to CreateClient.
Named clients
Named clients are a good choice when:
The app requires many distinct uses of HttpClient.
Many HttpClients have different configuration.
Specify configuration for a named HttpClient during its registration in Program.cs:
builder.Services.AddHttpClient("GitHub", httpClient =>
    httpClient.BaseAddress = new Uri("https://api.github.com/");
    // using Microsoft.Net.Http.Headers;
    // The GitHub API requires two headers.
    httpClient.DefaultRequestHeaders.Add(
        HeaderNames.Accept, "application/vnd.github.v3+json");
    httpClient.DefaultRequestHeaders.Add(
        HeaderNames.UserAgent, "HttpRequestsSample");
In the preceding code the client is configured with:
The base address https://api.github.com/.
Two headers required to work with the GitHub API.
CreateClient
Each time CreateClient is called:
A new instance of HttpClient is created.
The configuration action is called.
To create a named client, pass its name into CreateClient:
public class NamedClientModel : PageModel
    private readonly IHttpClientFactory _httpClientFactory;
    public NamedClientModel(IHttpClientFactory httpClientFactory) =>
        _httpClientFactory = httpClientFactory;
    public IEnumerable<GitHubBranch>? GitHubBranches { get; set; }
    public async Task OnGet()
        var httpClient = _httpClientFactory.CreateClient("GitHub");
        var httpResponseMessage = await httpClient.GetAsync(
            "repos/dotnet/AspNetCore.Docs/branches");
        if (httpResponseMessage.IsSuccessStatusCode)
            using var contentStream =
                await httpResponseMessage.Content.ReadAsStreamAsync();
            GitHubBranches = await JsonSerializer.DeserializeAsync
                <IEnumerable<GitHubBranch>>(contentStream);
In the preceding code, the request doesn't need to specify a hostname. The code can pass just the path, since the base address configured for the client is used.
Typed clients
Typed clients:
Provide the same capabilities as named clients without the need to use strings as keys.
Provides IntelliSense and compiler help when consuming clients.
Provide a single location to configure and interact with a particular HttpClient. For example, a single typed client might be used:
For a single backend endpoint.
To encapsulate all logic dealing with the endpoint.
Work with DI and can be injected where required in the app.
A typed client accepts an HttpClient parameter in its constructor:
public class GitHubService
    private readonly HttpClient _httpClient;
    public GitHubService(HttpClient httpClient)
        _httpClient = httpClient;
        _httpClient.BaseAddress = new Uri("https://api.github.com/");
        // using Microsoft.Net.Http.Headers;
        // The GitHub API requires two headers.
        _httpClient.DefaultRequestHeaders.Add(
            HeaderNames.Accept, "application/vnd.github.v3+json");
        _httpClient.DefaultRequestHeaders.Add(
            HeaderNames.UserAgent, "HttpRequestsSample");
    public async Task<IEnumerable<GitHubBranch>?> GetAspNetCoreDocsBranchesAsync() =>
        await _httpClient.GetFromJsonAsync<IEnumerable<GitHubBranch>>(
            "repos/dotnet/AspNetCore.Docs/branches");
In the preceding code:
The configuration is moved into the typed client.
The provided HttpClient instance is stored as a private field.
API-specific methods can be created that expose HttpClient functionality. For example, the GetAspNetCoreDocsBranches method encapsulates code to retrieve docs GitHub branches.
The following code calls AddHttpClient in Program.cs to register the GitHubService typed client class:
builder.Services.AddHttpClient<GitHubService>();
The typed client is registered as transient with DI. In the preceding code, AddHttpClient registers GitHubService as a transient service. This registration uses a factory method to:
Create an instance of HttpClient.
Create an instance of GitHubService, passing in the instance of HttpClient to its constructor.
The typed client can be injected and consumed directly:
public class TypedClientModel : PageModel
    private readonly GitHubService _gitHubService;
    public TypedClientModel(GitHubService gitHubService) =>
        _gitHubService = gitHubService;
    public IEnumerable<GitHubBranch>? GitHubBranches { get; set; }
    public async Task OnGet()
            GitHubBranches = await _gitHubService.GetAspNetCoreDocsBranchesAsync();
        catch (HttpRequestException)
            // ...
The configuration for a typed client can also be specified during its registration in Program.cs, rather than in the typed client's constructor:
builder.Services.AddHttpClient<GitHubService>(httpClient =>
    httpClient.BaseAddress = new Uri("https://api.github.com/");
    // ...
Generated clients
IHttpClientFactory can be used in combination with third-party libraries such as Refit. Refit is a REST library for .NET. It converts REST APIs into live interfaces. Call AddRefitClient to generate a dynamic implementation of an interface, which uses HttpClient to make the external HTTP calls.
A custom interface represents the external API:
public interface IGitHubClient
    [Get("/repos/dotnet/AspNetCore.Docs/branches")]
    Task<IEnumerable<GitHubBranch>> GetAspNetCoreDocsBranchesAsync();
Call AddRefitClient to generate the dynamic implementation and then call ConfigureHttpClient to configure the underlying HttpClient:
builder.Services.AddRefitClient<IGitHubClient>()
    .ConfigureHttpClient(httpClient =>
        httpClient.BaseAddress = new Uri("https://api.github.com/");
        // using Microsoft.Net.Http.Headers;
        // The GitHub API requires two headers.
        httpClient.DefaultRequestHeaders.Add(
            HeaderNames.Accept, "application/vnd.github.v3+json");
        httpClient.DefaultRequestHeaders.Add(
            HeaderNames.UserAgent, "HttpRequestsSample");
Use DI to access the dynamic implementation of IGitHubClient:
public class RefitModel : PageModel
    private readonly IGitHubClient _gitHubClient;
    public RefitModel(IGitHubClient gitHubClient) =>
        _gitHubClient = gitHubClient;
    public IEnumerable<GitHubBranch>? GitHubBranches { get; set; }
    public async Task OnGet()
            GitHubBranches = await _gitHubClient.GetAspNetCoreDocsBranchesAsync();
        catch (ApiException)
            // ...
Make POST, PUT, and DELETE requests
In the preceding examples, all HTTP requests use the GET HTTP verb. HttpClient also supports other HTTP verbs, including:
DELETE
PATCH
For a complete list of supported HTTP verbs, see HttpMethod.
The following example shows how to make an HTTP POST request:
public async Task CreateItemAsync(TodoItem todoItem)
    var todoItemJson = new StringContent(
        JsonSerializer.Serialize(todoItem),
        Encoding.UTF8,
        Application.Json); // using static System.Net.Mime.MediaTypeNames;
    using var httpResponseMessage =
        await _httpClient.PostAsync("/api/TodoItems", todoItemJson);
    httpResponseMessage.EnsureSuccessStatusCode();
In the preceding code, the CreateItemAsync method:
Serializes the TodoItem parameter to JSON using System.Text.Json.
Creates an instance of StringContent to package the serialized JSON for sending in the HTTP request's body.
Calls PostAsync to send the JSON content to the specified URL. This is a relative URL that gets added to the HttpClient.BaseAddress.
Calls EnsureSuccessStatusCode to throw an exception if the response status code doesn't indicate success.
HttpClient also supports other types of content. For example, MultipartContent and StreamContent. For a complete list of supported content, see HttpContent.
The following example shows an HTTP PUT request:
public async Task SaveItemAsync(TodoItem todoItem)
    var todoItemJson = new StringContent(
        JsonSerializer.Serialize(todoItem),
        Encoding.UTF8,
        Application.Json);
    using var httpResponseMessage =
        await _httpClient.PutAsync($"/api/TodoItems/{todoItem.Id}", todoItemJson);
    httpResponseMessage.EnsureSuccessStatusCode();
The preceding code is similar to the POST example. The SaveItemAsync method calls PutAsync instead of PostAsync.
The following example shows an HTTP DELETE request:
public async Task DeleteItemAsync(long itemId)
    using var httpResponseMessage =
        await _httpClient.DeleteAsync($"/api/TodoItems/{itemId}");
    httpResponseMessage.EnsureSuccessStatusCode();
In the preceding code, the DeleteItemAsync method calls DeleteAsync. Because HTTP DELETE requests typically contain no body, the DeleteAsync method doesn't provide an overload that accepts an instance of HttpContent.
To learn more about using different HTTP verbs with HttpClient, see HttpClient.
Outgoing request middleware
HttpClient has the concept of delegating handlers that can be linked together for outgoing HTTP requests. IHttpClientFactory:
Simplifies defining the handlers to apply for each named client.
Supports registration and chaining of multiple handlers to build an outgoing request middleware pipeline. Each of these handlers is able to perform work before and after the   outgoing request. This pattern:
Is similar to the inbound middleware pipeline in ASP.NET Core.
Provides a mechanism to manage cross-cutting concerns around HTTP requests, such as:
caching
error handling
serialization
logging
Derive from DelegatingHandler.
Override SendAsync. Execute code before passing the request to the next handler in the pipeline:
public class ValidateHeaderHandler : DelegatingHandler
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        if (!request.Headers.Contains("X-API-KEY"))
            return new HttpResponseMessage(HttpStatusCode.BadRequest)
                Content = new StringContent(
                    "The API key header X-API-KEY is required.")
        return await base.SendAsync(request, cancellationToken);
The preceding code checks if the X-API-KEY header is in the request. If X-API-KEY is missing, BadRequest is returned.




    

More than one handler can be added to the configuration for an HttpClient with Microsoft.Extensions.DependencyInjection.HttpClientBuilderExtensions.AddHttpMessageHandler:
builder.Services.AddTransient<ValidateHeaderHandler>();
builder.Services.AddHttpClient("HttpMessageHandler")
    .AddHttpMessageHandler<ValidateHeaderHandler>();
In the preceding code, the ValidateHeaderHandler is registered with DI. Once registered, AddHttpMessageHandler can be called, passing in the type for the handler.
Multiple handlers can be registered in the order that they should execute. Each handler wraps the next handler until the final HttpClientHandler executes the request:
builder.Services.AddTransient<SampleHandler1>();
builder.Services.AddTransient<SampleHandler2>();
builder.Services.AddHttpClient("MultipleHttpMessageHandlers")
    .AddHttpMessageHandler<SampleHandler1>()
    .AddHttpMessageHandler<SampleHandler2>();
In the preceding code, SampleHandler1 runs first, before SampleHandler2.
Use DI in outgoing request middleware
When IHttpClientFactory creates a new delegating handler, it uses DI to fulfill the handler's constructor parameters. IHttpClientFactory creates a separate DI scope for each handler, which can lead to surprising behavior when a handler consumes a scoped service.
For example, consider the following interface and its implementation, which represents a task as an operation with an identifier, OperationId:
public interface IOperationScoped
    string OperationId { get; }
public class OperationScoped : IOperationScoped
    public string OperationId { get; } = Guid.NewGuid().ToString()[^4..];
As its name suggests, IOperationScoped is registered with DI using a scoped lifetime:
builder.Services.AddScoped<IOperationScoped, OperationScoped>();
The following delegating handler consumes and uses IOperationScoped to set the X-OPERATION-ID header for the outgoing request:
public class OperationHandler : DelegatingHandler
    private readonly IOperationScoped _operationScoped;
    public OperationHandler(IOperationScoped operationScoped) =>
        _operationScoped = operationScoped;
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        request.Headers.Add("X-OPERATION-ID", _operationScoped.OperationId);
        return await base.SendAsync(request, cancellationToken);
In the HttpRequestsSample download, navigate to /Operation and refresh the page. The request scope value changes for each request, but the handler scope value only changes every 5 seconds.
Handlers can depend upon services of any scope. Services that handlers depend upon are disposed when the handler is disposed.
Use one of the following approaches to share per-request state with message handlers:
Pass data into the handler using HttpRequestMessage.Options.
Use IHttpContextAccessor to access the current request.
Create a custom AsyncLocal<T> storage object to pass the data.
Use Polly-based handlers
IHttpClientFactory integrates with the third-party library Polly. Polly is a comprehensive resilience and transient fault-handling library for .NET. It allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.
Extension methods are provided to enable the use of Polly policies with configured HttpClient instances. The Polly extensions support adding Polly-based handlers to clients. Polly requires the Microsoft.Extensions.Http.Polly NuGet package.
Handle transient faults
Faults typically occur when external HTTP calls are transient. AddTransientHttpErrorPolicy allows a policy to be defined to handle transient errors. Policies configured with AddTransientHttpErrorPolicy handle the following responses:
HttpRequestException
HTTP 5xx
HTTP 408
AddTransientHttpErrorPolicy provides access to a PolicyBuilder object configured to handle errors representing a possible transient fault:
builder.Services.AddHttpClient("PollyWaitAndRetry")
    .AddTransientHttpErrorPolicy(policyBuilder =>
        policyBuilder.WaitAndRetryAsync(
            3, retryNumber => TimeSpan.FromMilliseconds(600)));
In the preceding code, a WaitAndRetryAsync policy is defined. Failed requests are retried up to three times with a delay of 600 ms between attempts.
Dynamically select policies
Extension methods are provided to add Polly-based handlers, for example, AddPolicyHandler. The following AddPolicyHandler overload inspects the request to decide which policy to apply:
var timeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(10));
var longTimeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(30));
builder.Services.AddHttpClient("PollyDynamic")
    .AddPolicyHandler(httpRequestMessage =>
        httpRequestMessage.Method == HttpMethod.Get ? timeoutPolicy : longTimeoutPolicy);
In the preceding code, if the outgoing request is an HTTP GET, a 10-second timeout is applied. For any other HTTP method, a 30-second timeout is used.
Add multiple Polly handlers
It's common to nest Polly policies:
builder.Services.AddHttpClient("PollyMultiple")
    .AddTransientHttpErrorPolicy(policyBuilder =>
        policyBuilder.RetryAsync(3))
    .AddTransientHttpErrorPolicy(policyBuilder =>
        policyBuilder.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));
In the preceding example:
Two handlers are added.
The first handler uses AddTransientHttpErrorPolicy to add a retry policy. Failed requests are retried up to three times.
The second AddTransientHttpErrorPolicy call adds a circuit breaker policy. Further external requests are blocked for 30 seconds if 5 failed attempts occur sequentially. Circuit breaker policies are stateful. All calls through this client share the same circuit state.
Add policies from the Polly registry
An approach to managing regularly used policies is to define them once and register them with a PolicyRegistry. For example:
var timeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(10));
var longTimeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(30));
var policyRegistry = builder.Services.AddPolicyRegistry();
policyRegistry.Add("Regular", timeoutPolicy);
policyRegistry.Add("Long", longTimeoutPolicy);
builder.Services.AddHttpClient("PollyRegistryRegular")
    .AddPolicyHandlerFromRegistry("Regular");
builder.Services.AddHttpClient("PollyRegistryLong")
    .AddPolicyHandlerFromRegistry("Long");
In the preceding code:
Two policies, Regular and Long, are added to the Polly registry.
AddPolicyHandlerFromRegistry configures individual named clients to use these policies from the Polly registry.
For more information on IHttpClientFactory and Polly integrations, see the Polly wiki.
HttpClient and lifetime management
A new HttpClient instance is returned each time CreateClient is called on the IHttpClientFactory. An HttpMessageHandler is created per named client. The factory manages the lifetimes of the HttpMessageHandler instances.
IHttpClientFactory pools the HttpMessageHandler instances created by the factory to reduce resource consumption. An HttpMessageHandler instance may be reused from the pool when creating a new HttpClient instance if its lifetime hasn't expired.
Pooling of handlers is desirable as each handler typically manages its own underlying HTTP connections. Creating more handlers than necessary can result in connection delays. Some handlers also keep connections open indefinitely, which can prevent the handler from reacting to DNS (Domain Name System) changes.
The default handler lifetime is two minutes. The default value can be overridden on a per named client basis:
builder.Services.AddHttpClient("HandlerLifetime")
    .SetHandlerLifetime(TimeSpan.FromMinutes(5));
HttpClient instances can generally be treated as .NET objects not requiring disposal. Disposal cancels outgoing requests and guarantees the given HttpClient instance can't be used after calling Dispose. IHttpClientFactory tracks and disposes resources used by HttpClient instances.
Keeping a single HttpClient instance alive for a long duration is a common pattern used before the inception of IHttpClientFactory. This pattern becomes unnecessary after migrating to IHttpClientFactory.
Alternatives to IHttpClientFactory
Using IHttpClientFactory in a DI-enabled app avoids:
Resource exhaustion problems by pooling HttpMessageHandler instances.
Stale DNS problems by cycling HttpMessageHandler instances at regular intervals.
There are alternative ways to solve the preceding problems using a long-lived SocketsHttpHandler instance.
Create an instance of SocketsHttpHandler when the app starts and use it for the life of the app.
Configure PooledConnectionLifetime to an appropriate value based on DNS refresh times.
Create HttpClient instances using new HttpClient(handler, disposeHandler: false) as needed.
The preceding approaches solve the resource management problems that IHttpClientFactory solves in a similar way.
The SocketsHttpHandler shares connections across HttpClient instances. This sharing prevents socket exhaustion.
The SocketsHttpHandler cycles connections according to PooledConnectionLifetime to avoid stale DNS problems.
Logging
Clients created via IHttpClientFactory record log messages for all requests. Enable the appropriate information level in the logging configuration to see the default log messages. Additional logging, such as the logging of request headers, is only included at trace level.
The log category used for each client includes the name of the client. A client named MyNamedClient, for example, logs messages with a category of "System.Net.Http.HttpClient.MyNamedClient.LogicalHandler". Messages suffixed with LogicalHandler occur outside the request handler pipeline. On the request, messages are logged before any other handlers in the pipeline have processed it. On the response, messages are logged after any other pipeline handlers have received the response.
Logging also occurs inside the request handler pipeline. In the MyNamedClient example, those messages are logged with the log category "System.Net.Http.HttpClient.MyNamedClient.ClientHandler". For the request, this occurs after all other handlers have run and immediately before the request is sent. On the response, this logging includes the state of the response before it passes back through the handler pipeline.
Enabling logging outside and inside the pipeline enables inspection of the changes made by the other pipeline handlers. This may include changes to request headers or to the response status code.
Including the name of the client in the log category enables log filtering for specific named clients.
Configure the HttpMessageHandler
It may be necessary to control the configuration of the inner HttpMessageHandler used by a client.
An IHttpClientBuilder is returned when adding named or typed clients. The ConfigurePrimaryHttpMessageHandler extension method can be used to define a delegate. The delegate is used to create and configure the primary HttpMessageHandler used by that client:
builder.Services.AddHttpClient("ConfiguredHttpMessageHandler")
    .ConfigurePrimaryHttpMessageHandler(() =>
        new HttpClientHandler
            AllowAutoRedirect = true,
            UseDefaultCredentials = true
Cookies
The pooled HttpMessageHandler instances results in CookieContainer objects being shared. Unanticipated CookieContainer object sharing often results in incorrect code. For apps that require cookies, consider either:
Disabling automatic cookie handling
Avoiding IHttpClientFactory
Call ConfigurePrimaryHttpMessageHandler to disable automatic cookie handling:
builder.Services.AddHttpClient("NoAutomaticCookies")
    .ConfigurePrimaryHttpMessageHandler(() =>
        new HttpClientHandler
            UseCookies = false
Use IHttpClientFactory in a console app
In a console app, add the following package references to the project:
Microsoft.Extensions.Hosting
Microsoft.Extensions.Http
In the following example:




    

IHttpClientFactory and GitHubService are registered in the Generic Host's service container.
GitHubService is requested from DI, which in-turn requests an instance of IHttpClientFactory.
GitHubService uses IHttpClientFactory to create an instance of HttpClient, which it uses to retrieve docs GitHub branches.
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
var host = new HostBuilder()
    .ConfigureServices(services =>
        services.AddHttpClient();
        services.AddTransient<GitHubService>();
    .Build();
    var gitHubService = host.Services.GetRequiredService<GitHubService>();
    var gitHubBranches = await gitHubService.GetAspNetCoreDocsBranchesAsync();
    Console.WriteLine($"{gitHubBranches?.Count() ?? 0} GitHub Branches");
    if (gitHubBranches is not null)
        foreach (var gitHubBranch in gitHubBranches)
            Console.WriteLine($"- {gitHubBranch.Name}");
catch (Exception ex)
    host.Services.GetRequiredService<ILogger<Program>>()
        .LogError(ex, "Unable to load branches from GitHub.");
public class GitHubService
    private readonly IHttpClientFactory _httpClientFactory;
    public GitHubService(IHttpClientFactory httpClientFactory) =>
        _httpClientFactory = httpClientFactory;
    public async Task<IEnumerable<GitHubBranch>?> GetAspNetCoreDocsBranchesAsync()
        var httpRequestMessage = new HttpRequestMessage(
            HttpMethod.Get,
            "https://api.github.com/repos/dotnet/AspNetCore.Docs/branches")
            Headers =
                { "Accept", "application/vnd.github.v3+json" },
                { "User-Agent", "HttpRequestsConsoleSample" }
        var httpClient = _httpClientFactory.CreateClient();
        var httpResponseMessage = await httpClient.SendAsync(httpRequestMessage);
        httpResponseMessage.EnsureSuccessStatusCode();
        using var contentStream =
            await httpResponseMessage.Content.ReadAsStreamAsync();
        return await JsonSerializer.DeserializeAsync
            <IEnumerable<GitHubBranch>>(contentStream);
public record GitHubBranch(
    [property: JsonPropertyName("name")] string Name);
Header propagation middleware
Header propagation is an ASP.NET Core middleware to propagate HTTP headers from the incoming request to the outgoing HttpClient requests. To use header propagation:
Install the Microsoft.AspNetCore.HeaderPropagation package.
Configure the HttpClient and middleware pipeline in Program.cs:
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddHttpClient("PropagateHeaders")
    .AddHeaderPropagation();
builder.Services.AddHeaderPropagation(options =>
    options.Headers.Add("X-TraceId");
var app = builder.Build();
// Configure the HTTP request pipeline.
app.UseHttpsRedirection();
app.UseHeaderPropagation();
app.MapControllers();
Make outbound requests using the configured HttpClient instance, which includes the added headers.
Additional resources
View or download sample code (how to download)
Use HttpClientFactory to implement resilient HTTP requests
Implement HTTP call retries with exponential backoff with HttpClientFactory and Polly policies
Implement the Circuit Breaker pattern
How to serialize and deserialize JSON in .NET
By Kirk Larkin, Steve Gordon, Glenn Condron, and Ryan Nowak.
An IHttpClientFactory can be registered and used to configure and create HttpClient instances in an app. IHttpClientFactory offers the following benefits:
Provides a central location for naming and configuring logical HttpClient instances. For example, a client named  github could be registered and configured to access GitHub. A default client can be registered for general access.
Codifies the concept of outgoing middleware via delegating handlers in HttpClient. Provides extensions for Polly-based middleware to take advantage of delegating handlers in HttpClient.
Manages the pooling and lifetime of underlying HttpClientMessageHandler instances. Automatic management avoids common DNS (Domain Name System) problems that occur when manually managing HttpClient lifetimes.
Adds a configurable logging experience (via ILogger) for all requests sent through clients created by the factory.
View or download sample code (how to download).
The sample code in this topic version uses System.Text.Json to deserialize JSON content returned in HTTP responses. For samples that use Json.NET and ReadAsAsync<T>, use the version selector to select a 2.x version of this topic.
Consumption patterns
There are several ways IHttpClientFactory can be used in an app:
Basic usage
Named clients
Typed clients
Generated clients
The best approach depends upon the app's requirements.
Basic usage
IHttpClientFactory can be registered by calling AddHttpClient:
public class Startup
    public Startup(IConfiguration configuration)
        Configuration = configuration;
    public IConfiguration Configuration { get; }
    public void ConfigureServices(IServiceCollection services)
        services.AddHttpClient();
        // Remaining code deleted for brevity.
An IHttpClientFactory can be requested using dependency injection (DI). The following code uses IHttpClientFactory to create an HttpClient instance:
public class BasicUsageModel : PageModel
    private readonly IHttpClientFactory _clientFactory;
    public IEnumerable<GitHubBranch> Branches { get; private set; }
    public bool GetBranchesError { get; private set; }
    public BasicUsageModel(IHttpClientFactory clientFactory)
        _clientFactory = clientFactory;
    public async Task OnGet()
        var request = new HttpRequestMessage(HttpMethod.Get,
            "https://api.github.com/repos/dotnet/AspNetCore.Docs/branches");
        request.Headers.Add("Accept", "application/vnd.github.v3+json");
        request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
        var client = _clientFactory.CreateClient();
        var response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
            using var responseStream = await response.Content.ReadAsStreamAsync();
            Branches = await JsonSerializer.DeserializeAsync
                <IEnumerable<GitHubBranch>>(responseStream);
            GetBranchesError = true;
            Branches = Array.Empty<GitHubBranch>();
Using IHttpClientFactory like in the preceding example is a good way to refactor an existing app. It has no impact on how HttpClient is used. In places where HttpClient instances are created in an existing app, replace those occurrences with calls to CreateClient.
Named clients
Named clients are a good choice when:
The app requires many distinct uses of HttpClient.
Many HttpClients have different configuration.
Configuration for a named HttpClient can be specified during registration in Startup.ConfigureServices:
services.AddHttpClient("github", c =>
    c.BaseAddress = new Uri("https://api.github.com/");
    // Github API versioning
    c.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    // Github requires a user-agent
    c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
In the preceding code the client is configured with:
The base address https://api.github.com/.
Two headers required to work with the GitHub API.
CreateClient
Each time CreateClient is called:
A new instance of HttpClient is created.
The configuration action is called.
To create a named client, pass its name into CreateClient:
public class NamedClientModel : PageModel
    private readonly IHttpClientFactory _clientFactory;
    public IEnumerable<GitHubPullRequest> PullRequests { get; private set; }
    public bool GetPullRequestsError { get; private set; }
    public bool HasPullRequests => PullRequests.Any();
    public NamedClientModel(IHttpClientFactory clientFactory)
        _clientFactory = clientFactory;
    public async Task OnGet()
        var request = new HttpRequestMessage(HttpMethod.Get,
            "repos/dotnet/AspNetCore.Docs/pulls");
        var client = _clientFactory.CreateClient("github");
        var response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
            using var responseStream = await response.Content.ReadAsStreamAsync();
            PullRequests = await JsonSerializer.DeserializeAsync
                    <IEnumerable<GitHubPullRequest>>(responseStream);
            GetPullRequestsError = true;
            PullRequests = Array.Empty<GitHubPullRequest>();
In the preceding code, the request doesn't need to specify a hostname. The code can pass just the path, since the base address configured for the client is used.
Typed clients
Typed clients:
Provide the same capabilities as named clients without the need to use strings as keys.
Provides IntelliSense and compiler help when consuming clients.
Provide a single location to configure and interact with a particular HttpClient. For example, a single typed client might be used:
For a single backend endpoint.
To encapsulate all logic dealing with the endpoint.
Work with DI and can be injected where required in the app.
A typed client accepts an HttpClient parameter in its constructor:
public class GitHubService
    public HttpClient Client { get; }
    public GitHubService(HttpClient client)
        client.BaseAddress = new Uri("https://api.github.com/");
        // GitHub API versioning
        client.DefaultRequestHeaders.Add("Accept",
            "application/vnd.github.v3+json");
        // GitHub requires a user-agent
        client.DefaultRequestHeaders.Add("User-Agent",
            "HttpClientFactory-Sample");
        Client = client;
    public async Task<IEnumerable<GitHubIssue>> GetAspNetDocsIssues()
        return await Client.GetFromJsonAsync<IEnumerable<GitHubIssue>>(
          "/repos/aspnet/AspNetCore.Docs/issues?state=open&sort=created&direction=desc");
In the preceding code:
The configuration is moved into the typed client.
The HttpClient object is exposed as a public property.
API-specific methods can be created that expose HttpClient functionality. For example, the GetAspNetDocsIssues method encapsulates code to retrieve open issues.
The following code calls AddHttpClient in Startup.ConfigureServices to register a typed client class:
services.AddHttpClient<GitHubService>();
The typed client is registered as transient with DI. In the preceding code, AddHttpClient registers GitHubService as a transient service. This registration uses a factory method to:
Create an instance of HttpClient.
Create an instance of GitHubService, passing in the instance of HttpClient to its constructor.
The typed client can be injected and consumed directly:
public class TypedClientModel : PageModel
    private readonly GitHubService _gitHubService;
    public IEnumerable<GitHubIssue> LatestIssues { get; private set; }
    public bool HasIssue => LatestIssues.Any();
    public bool GetIssuesError { get; private set; }
    public TypedClientModel(GitHubService gitHubService)
        _gitHubService = gitHubService;
    public async Task OnGet()
            LatestIssues = await _gitHubService.GetAspNetDocsIssues();
        catch(HttpRequestException)
            GetIssuesError = true;
            LatestIssues = Array.Empty<GitHubIssue>();
The configuration for a typed client can be specified during registration in Startup.ConfigureServices, rather than in the typed client's constructor:
services.AddHttpClient<RepoService>(c =>
    c.BaseAddress = new Uri("https://api.github.com/");
    c.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
The HttpClient can be encapsulated within a typed client. Rather than exposing it as a property, define a method which calls the HttpClient instance internally:
public class RepoService
    // _httpClient isn't exposed publicly
    private readonly HttpClient _httpClient;
    public RepoService(HttpClient client)
        _httpClient = client;
    public async Task<IEnumerable<string>> GetRepos()
        var response = await _httpClient.GetAsync("aspnet/repos");
        response.EnsureSuccessStatusCode();
        using var responseStream = await response.Content.ReadAsStreamAsync();
        return await JsonSerializer.DeserializeAsync
            <IEnumerable<string>>(responseStream);
In the preceding code, the HttpClient is stored in a private field. Access to the HttpClient is by the public GetRepos method.
Generated clients
IHttpClientFactory can be used in combination with third-party libraries such as Refit. Refit is a REST library for .NET. It converts REST APIs into live interfaces. An implementation of the interface is generated dynamically by the RestService, using HttpClient to make the external HTTP calls.
An interface and a reply are defined to represent the external API and its response:
public interface IHelloClient
    [Get("/helloworld")]
    Task<Reply> GetMessageAsync();
public class Reply
    public string Message { get; set; }
A typed client can be added, using Refit to generate the implementation:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("hello", c =>
        c.BaseAddress = new Uri("http://localhost:5000");
    .AddTypedClient(c => Refit.RestService.For<IHelloClient>(c));
    services.AddControllers();
The defined interface can be consumed where necessary, with the implementation provided by DI and Refit:




    

[ApiController]
public class ValuesController : ControllerBase
    private readonly IHelloClient _client;
    public ValuesController(IHelloClient client)
        _client = client;
    [HttpGet("/")]
    public async Task<ActionResult<Reply>> Index()
        return await _client.GetMessageAsync();
Make POST, PUT, and DELETE requests
In the preceding examples, all HTTP requests use the GET HTTP verb. HttpClient also supports other HTTP verbs, including:
DELETE
PATCH
For a complete list of supported HTTP verbs, see HttpMethod.
The following example shows how to make an HTTP POST request:
public async Task CreateItemAsync(TodoItem todoItem)
    var todoItemJson = new StringContent(
        JsonSerializer.Serialize(todoItem, _jsonSerializerOptions),
        Encoding.UTF8,
        "application/json");
    using var httpResponse =
        await _httpClient.PostAsync("/api/TodoItems", todoItemJson);
    httpResponse.EnsureSuccessStatusCode();
In the preceding code, the CreateItemAsync method:
Serializes the TodoItem parameter to JSON using System.Text.Json. This uses an instance of JsonSerializerOptions to configure the serialization process.
Creates an instance of StringContent to package the serialized JSON for sending in the HTTP request's body.
Calls PostAsync to send the JSON content to the specified URL. This is a relative URL that gets added to the HttpClient.BaseAddress.
Calls EnsureSuccessStatusCode to throw an exception if the response status code does not indicate success.
HttpClient also supports other types of content. For example, MultipartContent and StreamContent. For a complete list of supported content, see HttpContent.
The following example shows an HTTP PUT request:
public async Task SaveItemAsync(TodoItem todoItem)
    var todoItemJson = new StringContent(
        JsonSerializer.Serialize(todoItem),
        Encoding.UTF8,
        "application/json");
    using var httpResponse =
        await _httpClient.PutAsync($"/api/TodoItems/{todoItem.Id}", todoItemJson);
    httpResponse.EnsureSuccessStatusCode();
The preceding code is very similar to the POST example. The SaveItemAsync method calls PutAsync instead of PostAsync.
The following example shows an HTTP DELETE request:
public async Task DeleteItemAsync(long itemId)
    using var httpResponse =
        await _httpClient.DeleteAsync($"/api/TodoItems/{itemId}");
    httpResponse.EnsureSuccessStatusCode();
In the preceding code, the DeleteItemAsync method calls DeleteAsync. Because HTTP DELETE requests typically contain no body, the DeleteAsync method doesn't provide an overload that accepts an instance of HttpContent.
To learn more about using different HTTP verbs with HttpClient, see HttpClient.
Outgoing request middleware
HttpClient has the concept of delegating handlers that can be linked together for outgoing HTTP requests. IHttpClientFactory:
Simplifies defining the handlers to apply for each named client.
Supports registration and chaining of multiple handlers to build an outgoing request middleware pipeline. Each of these handlers is able to perform work before and after the   outgoing request. This pattern:
Is similar to the inbound middleware pipeline in ASP.NET Core.
Provides a mechanism to manage cross-cutting concerns around HTTP requests, such as:
caching
error handling
serialization
logging
Derive from DelegatingHandler.
Override SendAsync. Execute code before passing the request to the next handler in the pipeline:
public class ValidateHeaderHandler : DelegatingHandler
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
        if (!request.Headers.Contains("X-API-KEY"))
            return new HttpResponseMessage(HttpStatusCode.BadRequest)
                Content = new StringContent(
                    "You must supply an API key header called X-API-KEY")
        return await base.SendAsync(request, cancellationToken);
The preceding code checks if the X-API-KEY header is in the request. If X-API-KEY is missing, BadRequest is returned.
More than one handler can be added to the configuration for an HttpClient with Microsoft.Extensions.DependencyInjection.HttpClientBuilderExtensions.AddHttpMessageHandler:
public void ConfigureServices(IServiceCollection services)
    services.AddTransient<ValidateHeaderHandler>();
    services.AddHttpClient("externalservice", c =>
        // Assume this is an "external" service which requires an API KEY
        c.BaseAddress = new Uri("https://localhost:5001/");
    .AddHttpMessageHandler<ValidateHeaderHandler>();
    // Remaining code deleted for brevity.
In the preceding code, the ValidateHeaderHandler is registered with DI. Once registered, AddHttpMessageHandler can be called, passing in the type for the handler.
Multiple handlers can be registered in the order that they should execute. Each handler wraps the next handler until the final HttpClientHandler executes the request:
services.AddTransient<SecureRequestHandler>();
services.AddTransient<RequestDataHandler>();
services.AddHttpClient("clientwithhandlers")
    // This handler is on the outside and called first during the 
    // request, last during the response.
    .AddHttpMessageHandler<SecureRequestHandler>()
    // This handler is on the inside, closest to the request being 
    // sent.
    .AddHttpMessageHandler<RequestDataHandler>();
Use DI in outgoing request middleware
When IHttpClientFactory creates a new delegating handler, it uses DI to fulfill the handler's constructor parameters. IHttpClientFactory creates a separate DI scope for each handler, which can lead to surprising behavior when a handler consumes a scoped service.
For example, consider the following interface and its implementation, which represents a task as an operation with an identifier, OperationId:
public interface IOperationScoped 
    string OperationId { get; }
public class OperationScoped : IOperationScoped
    public string OperationId { get; } = Guid.NewGuid().ToString()[^4..];
As its name suggests, IOperationScoped is registered with DI using a scoped lifetime:
public void ConfigureServices(IServiceCollection services)
    services.AddDbContext<TodoContext>(options =>
        options.UseInMemoryDatabase("TodoItems"));
    services.AddHttpContextAccessor();
    services.AddHttpClient<TodoClient>((sp, httpClient) =>
        var httpRequest = sp.GetRequiredService<IHttpContextAccessor>().HttpContext.Request;
        // For sample purposes, assume TodoClient is used in the context of an incoming request.
        httpClient.BaseAddress = new Uri(UriHelper.BuildAbsolute(httpRequest.Scheme,
                                         httpRequest.Host, httpRequest.PathBase));
        httpClient.Timeout = TimeSpan.FromSeconds(5);
    services.AddScoped<IOperationScoped, OperationScoped>();
    services.AddTransient<OperationHandler>();
    services.AddTransient<OperationResponseHandler>();
    services.AddHttpClient("Operation")
        .AddHttpMessageHandler<OperationHandler>()
        .AddHttpMessageHandler<OperationResponseHandler>()
        .SetHandlerLifetime(TimeSpan.FromSeconds(5));
    services.AddControllers();
    services.AddRazorPages();
The following delegating handler consumes and uses IOperationScoped to set the X-OPERATION-ID header for the outgoing request:
public class OperationHandler : DelegatingHandler
    private readonly IOperationScoped _operationService;
    public OperationHandler(IOperationScoped operationScoped)
        _operationService = operationScoped;
    protected async override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        request.Headers.Add("X-OPERATION-ID", _operationService.OperationId);
        return await base.SendAsync(request, cancellationToken);
In the HttpRequestsSample download], navigate to /Operation and refresh the page. The request scope value changes for each request, but the handler scope value only changes every 5 seconds.
Handlers can depend upon services of any scope. Services that handlers depend upon are disposed when the handler is disposed.
Use one of the following approaches to share per-request state with message handlers:
Pass data into the handler using HttpRequestMessage.Options.
Use IHttpContextAccessor to access the current request.
Create a custom AsyncLocal<T> storage object to pass the data.
Use Polly-based handlers
IHttpClientFactory integrates with the third-party library Polly. Polly is a comprehensive resilience and transient fault-handling library for .NET. It allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.
Extension methods are provided to enable the use of Polly policies with configured HttpClient instances. The Polly extensions support adding Polly-based handlers to clients. Polly requires the Microsoft.Extensions.Http.Polly NuGet package.
Handle transient faults
Faults typically occur when external HTTP calls are transient. AddTransientHttpErrorPolicy allows a policy to be defined to handle transient errors. Policies configured with AddTransientHttpErrorPolicy handle the following responses:
HttpRequestException
HTTP 5xx
HTTP 408
AddTransientHttpErrorPolicy provides access to a PolicyBuilder object configured to handle errors representing a possible transient fault:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient<UnreliableEndpointCallerService>()
        .AddTransientHttpErrorPolicy(p => 
            p.WaitAndRetryAsync(3, _ => TimeSpan.FromMilliseconds(600)));
    // Remaining code deleted for brevity.
In the preceding code, a WaitAndRetryAsync policy is defined. Failed requests are retried up to three times with a delay of 600 ms between attempts.
Dynamically select policies
Extension methods are provided to add Polly-based handlers, for example, AddPolicyHandler. The following AddPolicyHandler overload inspects the request to decide which policy to apply:
var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(10));
var longTimeout = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(30));
services.AddHttpClient("conditionalpolicy")
// Run some code to select a policy based on the request
    .AddPolicyHandler(request => 
        request.Method == HttpMethod.Get ? timeout : longTimeout);
In the preceding code, if the outgoing request is an HTTP GET, a 10-second timeout is applied. For any other HTTP method, a 30-second timeout is used.
Add multiple Polly handlers
It's common to nest Polly policies:
services.AddHttpClient("multiplepolicies")
    .AddTransientHttpErrorPolicy(p => p.RetryAsync(3))
    .AddTransientHttpErrorPolicy(
        p => p.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));
In the preceding example:
Two handlers are added.
The first handler uses AddTransientHttpErrorPolicy to add a retry policy. Failed requests are retried up to three times.
The second AddTransientHttpErrorPolicy call adds a circuit breaker policy. Further external requests are blocked for 30 seconds if 5 failed attempts occur sequentially. Circuit breaker policies are stateful. All calls through this client share the same circuit state.
Add policies from the Polly registry
An approach to managing regularly used policies is to define them once and register them with a PolicyRegistry.
In the following code:
The "regular" and "long" policies are added.
AddPolicyHandlerFromRegistry adds the "regular" and "long" policies from the registry.
public void ConfigureServices(IServiceCollection services)
    var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
        TimeSpan.FromSeconds(10));
    var longTimeout = Policy.TimeoutAsync<HttpResponseMessage>(
        TimeSpan.FromSeconds(30));
    var registry = services.AddPolicyRegistry();
    registry.Add("regular", timeout);
    registry.Add("long", longTimeout);
    services.AddHttpClient("regularTimeoutHandler")
        .AddPolicyHandlerFromRegistry("regular");
    services.AddHttpClient("longTimeoutHandler")
       .AddPolicyHandlerFromRegistry("long");
    // Remaining code deleted for brevity.
For more information on IHttpClientFactory and Polly integrations, see the Polly wiki.
HttpClient and lifetime management
A new HttpClient instance is returned each time CreateClient is called on the IHttpClientFactory. An HttpMessageHandler is created per named client. The factory manages the lifetimes of the HttpMessageHandler instances.
IHttpClientFactory pools the HttpMessageHandler instances created by the factory to reduce resource consumption. An HttpMessageHandler instance may be reused from the pool when creating a new HttpClient instance if its lifetime hasn't expired.




    

Pooling of handlers is desirable as each handler typically manages its own underlying HTTP connections. Creating more handlers than necessary can result in connection delays. Some handlers also keep connections open indefinitely, which can prevent the handler from reacting to DNS (Domain Name System) changes.
The default handler lifetime is two minutes. The default value can be overridden on a per named client basis:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("extendedhandlerlifetime")
        .SetHandlerLifetime(TimeSpan.FromMinutes(5));
    // Remaining code deleted for brevity.
HttpClient instances can generally be treated as .NET objects not requiring disposal. Disposal cancels outgoing requests and guarantees the given HttpClient instance can't be used after calling Dispose. IHttpClientFactory tracks and disposes resources used by HttpClient instances.
Keeping a single HttpClient instance alive for a long duration is a common pattern used before the inception of IHttpClientFactory. This pattern becomes unnecessary after migrating to IHttpClientFactory.
Alternatives to IHttpClientFactory
Using IHttpClientFactory in a DI-enabled app avoids:
Resource exhaustion problems by pooling HttpMessageHandler instances.
Stale DNS problems by cycling HttpMessageHandler instances at regular intervals.
There are alternative ways to solve the preceding problems using a long-lived SocketsHttpHandler instance.
Create an instance of SocketsHttpHandler when the app starts and use it for the life of the app.
Configure PooledConnectionLifetime to an appropriate value based on DNS refresh times.
Create HttpClient instances using new HttpClient(handler, disposeHandler: false) as needed.
The preceding approaches solve the resource management problems that IHttpClientFactory solves in a similar way.
The SocketsHttpHandler shares connections across HttpClient instances. This sharing prevents socket exhaustion.
The SocketsHttpHandler cycles connections according to PooledConnectionLifetime to avoid stale DNS problems.
Cookies
The pooled HttpMessageHandler instances results in CookieContainer objects being shared. Unanticipated CookieContainer object sharing often results in incorrect code. For apps that require cookies, consider either:
Disabling automatic cookie handling
Avoiding IHttpClientFactory
Call ConfigurePrimaryHttpMessageHandler to disable automatic cookie handling:
services.AddHttpClient("configured-disable-automatic-cookies")
    .ConfigurePrimaryHttpMessageHandler(() =>
        return new HttpClientHandler()
            UseCookies = false,
Logging
Clients created via IHttpClientFactory record log messages for all requests. Enable the appropriate information level in the logging configuration to see the default log messages. Additional logging, such as the logging of request headers, is only included at trace level.
The log category used for each client includes the name of the client. A client named MyNamedClient, for example, logs messages with a category of "System.Net.Http.HttpClient.MyNamedClient.LogicalHandler". Messages suffixed with LogicalHandler occur outside the request handler pipeline. On the request, messages are logged before any other handlers in the pipeline have processed it. On the response, messages are logged after any other pipeline handlers have received the response.
Logging also occurs inside the request handler pipeline. In the MyNamedClient example, those messages are logged with the log category "System.Net.Http.HttpClient.MyNamedClient.ClientHandler". For the request, this occurs after all other handlers have run and immediately before the request is sent. On the response, this logging includes the state of the response before it passes back through the handler pipeline.
Enabling logging outside and inside the pipeline enables inspection of the changes made by the other pipeline handlers. This may include changes to request headers or to the response status code.
Including the name of the client in the log category enables log filtering for specific named clients.
Configure the HttpMessageHandler
It may be necessary to control the configuration of the inner HttpMessageHandler used by a client.
An IHttpClientBuilder is returned when adding named or typed clients. The ConfigurePrimaryHttpMessageHandler extension method can be used to define a delegate. The delegate is used to create and configure the primary HttpMessageHandler used by that client:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("configured-inner-handler")
        .ConfigurePrimaryHttpMessageHandler(() =>
            return new HttpClientHandler()
                AllowAutoRedirect = false,
                UseDefaultCredentials = true
    // Remaining code deleted for brevity.
Use IHttpClientFactory in a console app
In a console app, add the following package references to the project:
Microsoft.Extensions.Hosting
Microsoft.Extensions.Http
In the following example:
IHttpClientFactory is registered in the Generic Host's service container.
MyService creates a client factory instance from the service, which is used to create an HttpClient. HttpClient is used to retrieve a webpage.
Main creates a scope to execute the service's GetPage method and write the first 500 characters of the webpage content to the console.
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
class Program
    static async Task<int> Main(string[] args)
        var builder = new HostBuilder()
            .ConfigureServices((hostContext, services) =>
                services.AddHttpClient();
                services.AddTransient<IMyService, MyService>();
            }).UseConsoleLifetime();
        var host = builder.Build();
            var myService = host.Services.GetRequiredService<IMyService>();
            var pageContent = await myService.GetPage();
            Console.WriteLine(pageContent.Substring(0, 500));
        catch (Exception ex)
            var logger = host.Services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred.");
        return 0;
    public interface IMyService
        Task<string> GetPage();
    public class MyService : IMyService
        private readonly IHttpClientFactory _clientFactory;
        public MyService(IHttpClientFactory clientFactory)
            _clientFactory = clientFactory;
        public async Task<string> GetPage()
            // Content from BBC One: Dr. Who website (©BBC)
            var request = new HttpRequestMessage(HttpMethod.Get,
                "https://www.bbc.co.uk/programmes/b006q2x0");
            var client = _clientFactory.CreateClient();
            var response = await client.SendAsync(request);
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsStringAsync();
                return $"StatusCode: {response.StatusCode}";
Header propagation middleware
Header propagation is an ASP.NET Core middleware to propagate HTTP headers from the incoming request to the outgoing HTTP Client requests. To use header propagation:
Reference the Microsoft.AspNetCore.HeaderPropagation package.
Configure the middleware and HttpClient in Startup:
public void ConfigureServices(IServiceCollection services)
    services.AddControllers();
    services.AddHttpClient("MyForwardingClient").AddHeaderPropagation();
    services.AddHeaderPropagation(options =>
        options.Headers.Add("X-TraceId");
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    if (env.IsDevelopment())
        app.UseDeveloperExceptionPage();
    app.UseHttpsRedirection();
    app.UseHeaderPropagation();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
        endpoints.MapControllers();
The client includes the configured headers on outbound requests:
var client = clientFactory.CreateClient("MyForwardingClient");
var response = client.GetAsync(...);
Additional resources
Use HttpClientFactory to implement resilient HTTP requests
Implement HTTP call retries with exponential backoff with HttpClientFactory and Polly policies
Implement the Circuit Breaker pattern
How to serialize and deserialize JSON in .NET
By Kirk Larkin, Steve Gordon, Glenn Condron, and Ryan Nowak.
An IHttpClientFactory can be registered and used to configure and create HttpClient instances in an app. IHttpClientFactory offers the following benefits:
Provides a central location for naming and configuring logical HttpClient instances. For example, a client named  github could be registered and configured to access GitHub. A default client can be registered for general access.
Codifies the concept of outgoing middleware via delegating handlers in HttpClient. Provides extensions for Polly-based middleware to take advantage of delegating handlers in HttpClient.
Manages the pooling and lifetime of underlying HttpClientMessageHandler instances. Automatic management avoids common DNS (Domain Name System) problems that occur when manually managing HttpClient lifetimes.
Adds a configurable logging experience (via ILogger) for all requests sent through clients created by the factory.
View or download sample code (how to download).
The sample code in this topic version uses System.Text.Json to deserialize JSON content returned in HTTP responses. For samples that use Json.NET and ReadAsAsync<T>, use the version selector to select a 2.x version of this topic.
Consumption patterns
There are several ways IHttpClientFactory can be used in an app:
Basic usage
Named clients
Typed clients
Generated clients
The best approach depends upon the app's requirements.
Basic usage
IHttpClientFactory can be registered by calling AddHttpClient:
public class Startup
    public Startup(IConfiguration configuration)
        Configuration = configuration;
    public IConfiguration Configuration { get; }
    public void ConfigureServices(IServiceCollection services)
        services.AddHttpClient();
        // Remaining code deleted for brevity.
An IHttpClientFactory can be requested using dependency injection (DI). The following code uses IHttpClientFactory to create an HttpClient instance:
public class BasicUsageModel : PageModel
    private readonly IHttpClientFactory _clientFactory;
    public IEnumerable<GitHubBranch> Branches { get; private set; }
    public bool GetBranchesError { get; private set; }
    public BasicUsageModel(IHttpClientFactory clientFactory)
        _clientFactory = clientFactory;
    public async Task OnGet()
        var request = new HttpRequestMessage(HttpMethod.Get,
            "https://api.github.com/repos/dotnet/AspNetCore.Docs/branches");
        request.Headers.Add("Accept", "application/vnd.github.v3+json");
        request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
        var client = _clientFactory.CreateClient();
        var response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
            using var responseStream = await response.Content.ReadAsStreamAsync();
            Branches = await JsonSerializer.DeserializeAsync
                <IEnumerable<GitHubBranch>>(responseStream);
            GetBranchesError = true;
            Branches = Array.Empty<GitHubBranch>();
Using IHttpClientFactory like in the preceding example is a good way to refactor an existing app. It has no impact on how HttpClient is used. In places where HttpClient instances are created in an existing app, replace those occurrences with calls to CreateClient.
Named clients
Named clients are a good choice when:
The app requires many distinct uses of HttpClient.
Many HttpClients have different configuration.
Configuration for a named HttpClient can be specified during registration in Startup.ConfigureServices:
services.AddHttpClient("github", c =>
    c.BaseAddress = new Uri("https://api.github.com/");
    // Github API versioning
    c.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    // Github requires a user-agent
    c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
In the preceding code the client is configured with:
The base address https://api.github.com/.
Two headers required to work with the GitHub API.
CreateClient
Each time CreateClient is called:
A new instance of HttpClient is created.
The configuration action is called.
To create a named client, pass its name into CreateClient:
public class NamedClientModel : PageModel
    private readonly IHttpClientFactory _clientFactory;
    public IEnumerable<GitHubPullRequest> PullRequests { get; private set; }
    public bool GetPullRequestsError { get; private set; }
    public bool HasPullRequests => PullRequests.Any();
    public NamedClientModel(IHttpClientFactory clientFactory)
        _clientFactory = clientFactory;
    public async Task OnGet()
        var request = new HttpRequestMessage(HttpMethod.Get,
            "repos/dotnet/AspNetCore.Docs/pulls");
        var client = _clientFactory.CreateClient("github");
        var response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
            using var responseStream = await response.Content.ReadAsStreamAsync();
            PullRequests = await JsonSerializer.DeserializeAsync
                    <IEnumerable<GitHubPullRequest>>(responseStream);
            GetPullRequestsError = true;
            PullRequests = Array.Empty<GitHubPullRequest>();
In the preceding code, the request doesn't need to specify a hostname. The code can pass just the path, since the base address configured for the client is used.




    

Typed clients
Typed clients:
Provide the same capabilities as named clients without the need to use strings as keys.
Provides IntelliSense and compiler help when consuming clients.
Provide a single location to configure and interact with a particular HttpClient. For example, a single typed client might be used:
For a single backend endpoint.
To encapsulate all logic dealing with the endpoint.
Work with DI and can be injected where required in the app.
A typed client accepts an HttpClient parameter in its constructor:
public class GitHubService
    public HttpClient Client { get; }
    public GitHubService(HttpClient client)
        client.BaseAddress = new Uri("https://api.github.com/");
        // GitHub API versioning
        client.DefaultRequestHeaders.Add("Accept",
            "application/vnd.github.v3+json");
        // GitHub requires a user-agent
        client.DefaultRequestHeaders.Add("User-Agent",
            "HttpClientFactory-Sample");
        Client = client;
    public async Task<IEnumerable<GitHubIssue>> GetAspNetDocsIssues()
        var response = await Client.GetAsync(
            "/repos/dotnet/AspNetCore.Docs/issues?state=open&sort=created&direction=desc");
        response.EnsureSuccessStatusCode();
        using var responseStream = await response.Content.ReadAsStreamAsync();
        return await JsonSerializer.DeserializeAsync
            <IEnumerable<GitHubIssue>>(responseStream);
If you would like to see code comments translated to languages other than English, let us know in this GitHub discussion issue.
In the preceding code:
The configuration is moved into the typed client.
The HttpClient object is exposed as a public property.
API-specific methods can be created that expose HttpClient functionality. For example, the GetAspNetDocsIssues method encapsulates code to retrieve open issues.
The following code calls AddHttpClient in Startup.ConfigureServices to register a typed client class:
services.AddHttpClient<GitHubService>();
The typed client is registered as transient with DI. In the preceding code, AddHttpClient registers GitHubService as a transient service. This registration uses a factory method to:
Create an instance of HttpClient.
Create an instance of GitHubService, passing in the instance of HttpClient to its constructor.
The typed client can be injected and consumed directly:
public class TypedClientModel : PageModel
    private readonly GitHubService _gitHubService;
    public IEnumerable<GitHubIssue> LatestIssues { get; private set; }
    public bool HasIssue => LatestIssues.Any();
    public bool GetIssuesError { get; private set; }
    public TypedClientModel(GitHubService gitHubService)
        _gitHubService = gitHubService;
    public async Task OnGet()
            LatestIssues = await _gitHubService.GetAspNetDocsIssues();
        catch(HttpRequestException)
            GetIssuesError = true;
            LatestIssues = Array.Empty<GitHubIssue>();
The configuration for a typed client can be specified during registration in Startup.ConfigureServices, rather than in the typed client's constructor:
services.AddHttpClient<RepoService>(c =>
    c.BaseAddress = new Uri("https://api.github.com/");
    c.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
The HttpClient can be encapsulated within a typed client. Rather than exposing it as a property, define a method which calls the HttpClient instance internally:
public class RepoService
    // _httpClient isn't exposed publicly
    private readonly HttpClient _httpClient;
    public RepoService(HttpClient client)
        _httpClient = client;
    public async Task<IEnumerable<string>> GetRepos()
        var response = await _httpClient.GetAsync("aspnet/repos");
        response.EnsureSuccessStatusCode();
        using var responseStream = await response.Content.ReadAsStreamAsync();
        return await JsonSerializer.DeserializeAsync
            <IEnumerable<string>>(responseStream);
In the preceding code, the HttpClient is stored in a private field. Access to the HttpClient is by the public GetRepos method.
Generated clients
IHttpClientFactory can be used in combination with third-party libraries such as Refit. Refit is a REST library for .NET. It converts REST APIs into live interfaces. An implementation of the interface is generated dynamically by the RestService, using HttpClient to make the external HTTP calls.
An interface and a reply are defined to represent the external API and its response:
public interface IHelloClient
    [Get("/helloworld")]
    Task<Reply> GetMessageAsync();
public class Reply
    public string Message { get; set; }
A typed client can be added, using Refit to generate the implementation:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("hello", c =>
        c.BaseAddress = new Uri("http://localhost:5000");
    .AddTypedClient(c => Refit.RestService.For<IHelloClient>(c));
    services.AddControllers();
The defined interface can be consumed where necessary, with the implementation provided by DI and Refit:
[ApiController]
public class ValuesController : ControllerBase
    private readonly IHelloClient _client;
    public ValuesController(IHelloClient client)
        _client = client;
    [HttpGet("/")]
    public async Task<ActionResult<Reply>> Index()
        return await _client.GetMessageAsync();
Make POST, PUT, and DELETE requests
In the preceding examples, all HTTP requests use the GET HTTP verb. HttpClient also supports other HTTP verbs, including:
DELETE
PATCH
For a complete list of supported HTTP verbs, see HttpMethod.
The following example shows how to make an HTTP POST request:
public async Task CreateItemAsync(TodoItem todoItem)
    var todoItemJson = new StringContent(
        JsonSerializer.Serialize(todoItem, _jsonSerializerOptions),
        Encoding.UTF8,
        "application/json");
    using var httpResponse =
        await _httpClient.PostAsync("/api/TodoItems", todoItemJson);
    httpResponse.EnsureSuccessStatusCode();
In the preceding code, the CreateItemAsync method:
Serializes the TodoItem parameter to JSON using System.Text.Json. This uses an instance of JsonSerializerOptions to configure the serialization process.
Creates an instance of StringContent to package the serialized JSON for sending in the HTTP request's body.
Calls PostAsync to send the JSON content to the specified URL. This is a relative URL that gets added to the HttpClient.BaseAddress.
Calls EnsureSuccessStatusCode to throw an exception if the response status code does not indicate success.
HttpClient also supports other types of content. For example, MultipartContent and StreamContent. For a complete list of supported content, see HttpContent.
The following example shows an HTTP PUT request:
public async Task SaveItemAsync(TodoItem todoItem)
    var todoItemJson = new StringContent(
        JsonSerializer.Serialize(todoItem),
        Encoding.UTF8,
        "application/json");
    using var httpResponse =
        await _httpClient.PutAsync($"/api/TodoItems/{todoItem.Id}", todoItemJson);
    httpResponse.EnsureSuccessStatusCode();
The preceding code is very similar to the POST example. The SaveItemAsync method calls PutAsync instead of PostAsync.
The following example shows an HTTP DELETE request:
public async Task DeleteItemAsync(long itemId)
    using var httpResponse =
        await _httpClient.DeleteAsync($"/api/TodoItems/{itemId}");
    httpResponse.EnsureSuccessStatusCode();
In the preceding code, the DeleteItemAsync method calls DeleteAsync. Because HTTP DELETE requests typically contain no body, the DeleteAsync method doesn't provide an overload that accepts an instance of HttpContent.
To learn more about using different HTTP verbs with HttpClient, see HttpClient.
Outgoing request middleware
HttpClient has the concept of delegating handlers that can be linked together for outgoing HTTP requests. IHttpClientFactory:
Simplifies defining the handlers to apply for each named client.
Supports registration and chaining of multiple handlers to build an outgoing request middleware pipeline. Each of these handlers is able to perform work before and after the   outgoing request. This pattern:
Is similar to the inbound middleware pipeline in ASP.NET Core.
Provides a mechanism to manage cross-cutting concerns around HTTP requests, such as:
caching
error handling
serialization
logging
Derive from DelegatingHandler.
Override SendAsync. Execute code before passing the request to the next handler in the pipeline:
public class ValidateHeaderHandler : DelegatingHandler
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
        if (!request.Headers.Contains("X-API-KEY"))
            return new HttpResponseMessage(HttpStatusCode.BadRequest)
                Content = new StringContent(
                    "You must supply an API key header called X-API-KEY")
        return await base.SendAsync(request, cancellationToken);
The preceding code checks if the X-API-KEY header is in the request. If X-API-KEY is missing, BadRequest is returned.
More than one handler can be added to the configuration for an HttpClient with Microsoft.Extensions.DependencyInjection.HttpClientBuilderExtensions.AddHttpMessageHandler:
public void ConfigureServices(IServiceCollection services)
    services.AddTransient<ValidateHeaderHandler>();
    services.AddHttpClient("externalservice", c =>
        // Assume this is an "external" service which requires an API KEY
        c.BaseAddress = new Uri("https://localhost:5001/");
    .AddHttpMessageHandler<ValidateHeaderHandler>();
    // Remaining code deleted for brevity.
In the preceding code, the ValidateHeaderHandler is registered with DI. Once registered, AddHttpMessageHandler can be called, passing in the type for the handler.
Multiple handlers can be registered in the order that they should execute. Each handler wraps the next handler until the final HttpClientHandler executes the request:
services.AddTransient<SecureRequestHandler>();
services.AddTransient<RequestDataHandler>();
services.AddHttpClient("clientwithhandlers")
    // This handler is on the outside and called first during the 
    // request, last during the response.
    .AddHttpMessageHandler<SecureRequestHandler>()
    // This handler is on the inside, closest to the request being 
    // sent.
    .AddHttpMessageHandler<RequestDataHandler>();
Use DI in outgoing request middleware
When IHttpClientFactory creates a new delegating handler, it uses DI to fulfill the handler's constructor parameters. IHttpClientFactory creates a separate DI scope for each handler, which can lead to surprising behavior when a handler consumes a scoped service.
For example, consider the following interface and its implementation, which represents a task as an operation with an identifier, OperationId:
public interface IOperationScoped 
    string OperationId { get; }
public class OperationScoped : IOperationScoped
    public string OperationId { get; } = Guid.NewGuid().ToString()[^4..];
As its name suggests, IOperationScoped is registered with DI using a scoped lifetime:
public void ConfigureServices(IServiceCollection services)
    services.AddDbContext<TodoContext>(options =>
        options.UseInMemoryDatabase("TodoItems"));
    services.AddHttpContextAccessor();
    services.AddHttpClient<TodoClient>((sp, httpClient) =>
        var httpRequest = sp.GetRequiredService<IHttpContextAccessor>().HttpContext.Request;
        // For sample purposes, assume TodoClient is used in the context of an incoming request.
        httpClient.BaseAddress = new Uri(UriHelper.BuildAbsolute(httpRequest.Scheme,
                                         httpRequest.Host, httpRequest.PathBase));
        httpClient.Timeout = TimeSpan.FromSeconds(5);
    services.AddScoped<IOperationScoped, OperationScoped>();
    services.AddTransient<OperationHandler>();
    services.AddTransient<OperationResponseHandler>();
    services.AddHttpClient("Operation")
        .AddHttpMessageHandler<OperationHandler>()
        .AddHttpMessageHandler<OperationResponseHandler>()
        .SetHandlerLifetime(TimeSpan.FromSeconds(5));
    services.AddControllers();
    services.AddRazorPages();
The following delegating handler consumes and uses IOperationScoped to set the X-OPERATION-ID header for the outgoing request:
public class OperationHandler : DelegatingHandler
    private readonly IOperationScoped _operationService;
    public OperationHandler(IOperationScoped operationScoped)
        _operationService = operationScoped;
    protected async override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        request.Headers.Add("X-OPERATION-ID", _operationService.OperationId);
        return await base.SendAsync(request, cancellationToken);
In the HttpRequestsSample download], navigate to /Operation and refresh the page. The request scope value changes for each request, but the handler scope value only changes every 5 seconds.
Handlers can depend upon services of any scope. Services that handlers depend upon are disposed when the handler is disposed.
Use one of the following approaches to share per-request state with message handlers:
Pass data into the handler using HttpRequestMessage.Properties.
Use IHttpContextAccessor to access the current request.
Create a custom AsyncLocal<T> storage object to pass the data.
Use Polly-based handlers
IHttpClientFactory integrates with the third-party library Polly. Polly is a comprehensive resilience and transient fault-handling library for .NET. It allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.




    

Extension methods are provided to enable the use of Polly policies with configured HttpClient instances. The Polly extensions support adding Polly-based handlers to clients. Polly requires the Microsoft.Extensions.Http.Polly NuGet package.
Handle transient faults
Faults typically occur when external HTTP calls are transient. AddTransientHttpErrorPolicy allows a policy to be defined to handle transient errors. Policies configured with AddTransientHttpErrorPolicy handle the following responses:
HttpRequestException
HTTP 5xx
HTTP 408
AddTransientHttpErrorPolicy provides access to a PolicyBuilder object configured to handle errors representing a possible transient fault:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient<UnreliableEndpointCallerService>()
        .AddTransientHttpErrorPolicy(p => 
            p.WaitAndRetryAsync(3, _ => TimeSpan.FromMilliseconds(600)));
    // Remaining code deleted for brevity.
In the preceding code, a WaitAndRetryAsync policy is defined. Failed requests are retried up to three times with a delay of 600 ms between attempts.
Dynamically select policies
Extension methods are provided to add Polly-based handlers, for example, AddPolicyHandler. The following AddPolicyHandler overload inspects the request to decide which policy to apply:
var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(10));
var longTimeout = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(30));
services.AddHttpClient("conditionalpolicy")
// Run some code to select a policy based on the request
    .AddPolicyHandler(request => 
        request.Method == HttpMethod.Get ? timeout : longTimeout);
In the preceding code, if the outgoing request is an HTTP GET, a 10-second timeout is applied. For any other HTTP method, a 30-second timeout is used.
Add multiple Polly handlers
It's common to nest Polly policies:
services.AddHttpClient("multiplepolicies")
    .AddTransientHttpErrorPolicy(p => p.RetryAsync(3))
    .AddTransientHttpErrorPolicy(
        p => p.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));
In the preceding example:
Two handlers are added.
The first handler uses AddTransientHttpErrorPolicy to add a retry policy. Failed requests are retried up to three times.
The second AddTransientHttpErrorPolicy call adds a circuit breaker policy. Further external requests are blocked for 30 seconds if 5 failed attempts occur sequentially. Circuit breaker policies are stateful. All calls through this client share the same circuit state.
Add policies from the Polly registry
An approach to managing regularly used policies is to define them once and register them with a PolicyRegistry.
In the following code:
The "regular" and "long" policies are added.
AddPolicyHandlerFromRegistry adds the "regular" and "long" policies from the registry.
public void ConfigureServices(IServiceCollection services)
    var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
        TimeSpan.FromSeconds(10));
    var longTimeout = Policy.TimeoutAsync<HttpResponseMessage>(
        TimeSpan.FromSeconds(30));
    var registry = services.AddPolicyRegistry();
    registry.Add("regular", timeout);
    registry.Add("long", longTimeout);
    services.AddHttpClient("regularTimeoutHandler")
        .AddPolicyHandlerFromRegistry("regular");
    services.AddHttpClient("longTimeoutHandler")
       .AddPolicyHandlerFromRegistry("long");
    // Remaining code deleted for brevity.
For more information on IHttpClientFactory and Polly integrations, see the Polly wiki.
HttpClient and lifetime management
A new HttpClient instance is returned each time CreateClient is called on the IHttpClientFactory. An HttpMessageHandler is created per named client. The factory manages the lifetimes of the HttpMessageHandler instances.
IHttpClientFactory pools the HttpMessageHandler instances created by the factory to reduce resource consumption. An HttpMessageHandler instance may be reused from the pool when creating a new HttpClient instance if its lifetime hasn't expired.
Pooling of handlers is desirable as each handler typically manages its own underlying HTTP connections. Creating more handlers than necessary can result in connection delays. Some handlers also keep connections open indefinitely, which can prevent the handler from reacting to DNS (Domain Name System) changes.
The default handler lifetime is two minutes. The default value can be overridden on a per named client basis:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("extendedhandlerlifetime")
        .SetHandlerLifetime(TimeSpan.FromMinutes(5));
    // Remaining code deleted for brevity.
HttpClient instances can generally be treated as .NET objects not requiring disposal. Disposal cancels outgoing requests and guarantees the given HttpClient instance can't be used after calling Dispose. IHttpClientFactory tracks and disposes resources used by HttpClient instances.
Keeping a single HttpClient instance alive for a long duration is a common pattern used before the inception of IHttpClientFactory. This pattern becomes unnecessary after migrating to IHttpClientFactory.
Alternatives to IHttpClientFactory
Using IHttpClientFactory in a DI-enabled app avoids:
Resource exhaustion problems by pooling HttpMessageHandler instances.
Stale DNS problems by cycling HttpMessageHandler instances at regular intervals.
There are alternative ways to solve the preceding problems using a long-lived SocketsHttpHandler instance.
Create an instance of SocketsHttpHandler when the app starts and use it for the life of the app.
Configure PooledConnectionLifetime to an appropriate value based on DNS refresh times.
Create HttpClient instances using new HttpClient(handler, disposeHandler: false) as needed.
The preceding approaches solve the resource management problems that IHttpClientFactory solves in a similar way.
The SocketsHttpHandler shares connections across HttpClient instances. This sharing prevents socket exhaustion.
The SocketsHttpHandler cycles connections according to PooledConnectionLifetime to avoid stale DNS problems.
Cookies
The pooled HttpMessageHandler instances results in CookieContainer objects being shared. Unanticipated CookieContainer object sharing often results in incorrect code. For apps that require cookies, consider either:
Disabling automatic cookie handling
Avoiding IHttpClientFactory
Call ConfigurePrimaryHttpMessageHandler to disable automatic cookie handling:
services.AddHttpClient("configured-disable-automatic-cookies")
    .ConfigurePrimaryHttpMessageHandler(() =>
        return new HttpClientHandler()
            UseCookies = false,
Logging
Clients created via IHttpClientFactory record log messages for all requests. Enable the appropriate information level in the logging configuration to see the default log messages. Additional logging, such as the logging of request headers, is only included at trace level.
The log category used for each client includes the name of the client. A client named MyNamedClient, for example, logs messages with a category of "System.Net.Http.HttpClient.MyNamedClient.LogicalHandler". Messages suffixed with LogicalHandler occur outside the request handler pipeline. On the request, messages are logged before any other handlers in the pipeline have processed it. On the response, messages are logged after any other pipeline handlers have received the response.
Logging also occurs inside the request handler pipeline. In the MyNamedClient example, those messages are logged with the log category "System.Net.Http.HttpClient.MyNamedClient.ClientHandler". For the request, this occurs after all other handlers have run and immediately before the request is sent. On the response, this logging includes the state of the response before it passes back through the handler pipeline.
Enabling logging outside and inside the pipeline enables inspection of the changes made by the other pipeline handlers. This may include changes to request headers or to the response status code.
Including the name of the client in the log category enables log filtering for specific named clients.
Configure the HttpMessageHandler
It may be necessary to control the configuration of the inner HttpMessageHandler used by a client.
An IHttpClientBuilder is returned when adding named or typed clients. The ConfigurePrimaryHttpMessageHandler extension method can be used to define a delegate. The delegate is used to create and configure the primary HttpMessageHandler used by that client:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("configured-inner-handler")
        .ConfigurePrimaryHttpMessageHandler(() =>
            return new HttpClientHandler()
                AllowAutoRedirect = false,
                UseDefaultCredentials = true
    // Remaining code deleted for brevity.
Use IHttpClientFactory in a console app
In a console app, add the following package references to the project:
Microsoft.Extensions.Hosting
Microsoft.Extensions.Http
In the following example:
IHttpClientFactory is registered in the Generic Host's service container.
MyService creates a client factory instance from the service, which is used to create an HttpClient. HttpClient is used to retrieve a webpage.
Main creates a scope to execute the service's GetPage method and write the first 500 characters of the webpage content to the console.
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
class Program
    static async Task<int> Main(string[] args)
        var builder = new HostBuilder()
            .ConfigureServices((hostContext, services) =>
                services.AddHttpClient();
                services.AddTransient<IMyService, MyService>();
            }).UseConsoleLifetime();
        var host = builder.Build();
            var myService = host.Services.GetRequiredService<IMyService>();
            var pageContent = await myService.GetPage();
            Console.WriteLine(pageContent.Substring(0, 500));
        catch (Exception ex)
            var logger = host.Services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred.");
        return 0;
    public interface IMyService
        Task<string> GetPage();
    public class MyService : IMyService
        private readonly IHttpClientFactory _clientFactory;
        public MyService(IHttpClientFactory clientFactory)
            _clientFactory = clientFactory;
        public async Task<string> GetPage()
            // Content from BBC One: Dr. Who website (©BBC)
            var request = new HttpRequestMessage(HttpMethod.Get,
                "https://www.bbc.co.uk/programmes/b006q2x0");
            var client = _clientFactory.CreateClient();
            var response = await client.SendAsync(request);
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsStringAsync();
                return $"StatusCode: {response.StatusCode}";
Header propagation middleware
Header propagation is an ASP.NET Core middleware to propagate HTTP headers from the incoming request to the outgoing HTTP Client requests. To use header propagation:
Reference the Microsoft.AspNetCore.HeaderPropagation package.
Configure the middleware and HttpClient in Startup:
public void ConfigureServices(IServiceCollection services)
    services.AddControllers();
    services.AddHttpClient("MyForwardingClient").AddHeaderPropagation();
    services.AddHeaderPropagation(options =>
        options.Headers.Add("X-TraceId");
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    if (env.IsDevelopment())
        app.UseDeveloperExceptionPage();
    app.UseHttpsRedirection();
    app.UseHeaderPropagation();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
        endpoints.MapControllers();
The client includes the configured headers on outbound requests:
var client = clientFactory.CreateClient("MyForwardingClient");
var response = client.GetAsync(...);
Additional resources
Use HttpClientFactory to implement resilient HTTP requests
Implement HTTP call retries with exponential backoff with HttpClientFactory and Polly policies
Implement the Circuit Breaker pattern
How to serialize and deserialize JSON in .NET
By Glenn Condron, Ryan Nowak, and Steve Gordon
An IHttpClientFactory can be registered and used to configure and create HttpClient instances in an app. It offers the following benefits:




    

Provides a central location for naming and configuring logical HttpClient instances. For example, a github client can be registered and configured to access GitHub. A default client can be registered for other purposes.
Codifies the concept of outgoing middleware via delegating handlers in HttpClient and provides extensions for Polly-based middleware to take advantage of that.
Manages the pooling and lifetime of underlying HttpClientMessageHandler instances to avoid common DNS problems that occur when manually managing HttpClient lifetimes.
Adds a configurable logging experience (via ILogger) for all requests sent through clients created by the factory.
View or download sample code (how to download)
Prerequisites
Projects targeting .NET Framework require installation of the Microsoft.Extensions.Http NuGet package. Projects that target .NET Core and reference the Microsoft.AspNetCore.App metapackage already include the Microsoft.Extensions.Http package.
Consumption patterns
There are several ways IHttpClientFactory can be used in an app:
Basic usage
Named clients
Typed clients
Generated clients
None of them are strictly superior to another. The best approach depends upon the app's constraints.
Basic usage
The IHttpClientFactory can be registered by calling the AddHttpClient extension method on the IServiceCollection, inside the Startup.ConfigureServices method.
services.AddHttpClient();
Once registered, code can accept an IHttpClientFactory anywhere services can be injected with dependency injection (DI). The IHttpClientFactory can be used to create an HttpClient instance:
public class BasicUsageModel : PageModel
    private readonly IHttpClientFactory _clientFactory;
    public IEnumerable<GitHubBranch> Branches { get; private set; }
    public bool GetBranchesError { get; private set; }
    public BasicUsageModel(IHttpClientFactory clientFactory)
        _clientFactory = clientFactory;
    public async Task OnGet()
        var request = new HttpRequestMessage(HttpMethod.Get, 
            "https://api.github.com/repos/dotnet/AspNetCore.Docs/branches");
        request.Headers.Add("Accept", "application/vnd.github.v3+json");
        request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
        var client = _clientFactory.CreateClient();
        var response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
            Branches = await response.Content
                .ReadAsAsync<IEnumerable<GitHubBranch>>();
            GetBranchesError = true;
            Branches = Array.Empty<GitHubBranch>();
Using IHttpClientFactory in this fashion is a good way to refactor an existing app. It has no impact on the way HttpClient is used. In places where HttpClient instances are currently created, replace those occurrences with a call to CreateClient.
Named clients
If an app requires many distinct uses of HttpClient, each with a different configuration, an option is to use named clients. Configuration for a named HttpClient can be specified during registration in Startup.ConfigureServices.
services.AddHttpClient("github", c =>
    c.BaseAddress = new Uri("https://api.github.com/");
    // Github API versioning
    c.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    // Github requires a user-agent
    c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
In the preceding code, AddHttpClient is called, providing the name github. This client has some default configuration applied—namely the base address and two headers required to work with the GitHub API.
Each time CreateClient is called, a new instance of HttpClient is created and the configuration action is called.
To consume a named client, a string parameter can be passed to CreateClient. Specify the name of the client to be created:
public class NamedClientModel : PageModel
    private readonly IHttpClientFactory _clientFactory;
    public IEnumerable<GitHubPullRequest> PullRequests { get; private set; }
    public bool GetPullRequestsError { get; private set; }
    public bool HasPullRequests => PullRequests.Any();
    public NamedClientModel(IHttpClientFactory clientFactory)
        _clientFactory = clientFactory;
    public async Task OnGet()
        var request = new HttpRequestMessage(HttpMethod.Get, 
            "repos/dotnet/AspNetCore.Docs/pulls");
        var client = _clientFactory.CreateClient("github");
        var response = await client.SendAsync(request);
        if (response.IsSuccessStatusCode)
            PullRequests = await response.Content
                .ReadAsAsync<IEnumerable<GitHubPullRequest>>();
            GetPullRequestsError = true;
            PullRequests = Array.Empty<GitHubPullRequest>();
In the preceding code, the request doesn't need to specify a hostname. It can pass just the path, since the base address configured for the client is used.
Typed clients
Typed clients:
Provide the same capabilities as named clients without the need to use strings as keys.
Provides IntelliSense and compiler help when consuming clients.
Provide a single location to configure and interact with a particular HttpClient. For example, a single typed client might be used for a single backend endpoint and encapsulate all logic dealing with that endpoint.
Work with DI and can be injected where required in your app.
A typed client accepts an HttpClient parameter in its constructor:
public class GitHubService
    public HttpClient Client { get; }
    public GitHubService(HttpClient client)
        client.BaseAddress = new Uri("https://api.github.com/");
        // GitHub API versioning
        client.DefaultRequestHeaders.Add("Accept", 
            "application/vnd.github.v3+json");
        // GitHub requires a user-agent
        client.DefaultRequestHeaders.Add("User-Agent", 
            "HttpClientFactory-Sample");
        Client = client;
    public async Task<IEnumerable<GitHubIssue>> GetAspNetDocsIssues()
        var response = await Client.GetAsync(
            "/repos/dotnet/AspNetCore.Docs/issues?state=open&sort=created&direction=desc");
        response.EnsureSuccessStatusCode();
        var result = await response.Content
            .ReadAsAsync<IEnumerable<GitHubIssue>>();
        return result;
In the preceding code, the configuration is moved into the typed client. The HttpClient object is exposed as a public property. It's possible to define API-specific methods that expose HttpClient functionality. The GetAspNetDocsIssues method encapsulates the code needed to query for and parse out the latest open issues from a GitHub repository.
To register a typed client, the generic AddHttpClient extension method can be used within Startup.ConfigureServices, specifying the typed client class:
services.AddHttpClient<GitHubService>();
The typed client is registered as transient with DI. The typed client can be injected and consumed directly:
public class TypedClientModel : PageModel
    private readonly GitHubService _gitHubService;
    public IEnumerable<GitHubIssue> LatestIssues { get; private set; }
    public bool HasIssue => LatestIssues.Any();
    public bool GetIssuesError { get; private set; }
    public TypedClientModel(GitHubService gitHubService)
        _gitHubService = gitHubService;
    public async Task OnGet()
            LatestIssues = await _gitHubService.GetAspNetDocsIssues();
        catch(HttpRequestException)
            GetIssuesError = true;
            LatestIssues = Array.Empty<GitHubIssue>();
If preferred, the configuration for a typed client can be specified during registration in Startup.ConfigureServices, rather than in the typed client's constructor:
services.AddHttpClient<RepoService>(c =>
    c.BaseAddress = new Uri("https://api.github.com/");
    c.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    c.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
It's possible to entirely encapsulate the HttpClient within a typed client. Rather than exposing it as a property, public methods can be provided which call the HttpClient instance internally.
public class RepoService
    // _httpClient isn't exposed publicly
    private readonly HttpClient _httpClient;
    public RepoService(HttpClient client)
        _httpClient = client;
    public async Task<IEnumerable<string>> GetRepos()
        var response = await _httpClient.GetAsync("aspnet/repos");
        response.EnsureSuccessStatusCode();
        var result = await response.Content
            .ReadAsAsync<IEnumerable<string>>();
        return result;
In the preceding code, the HttpClient is stored as a private field. All access to make external calls goes through the GetRepos method.
Generated clients
IHttpClientFactory can be used in combination with other third-party libraries such as Refit. Refit is a REST library for .NET. It converts REST APIs into live interfaces. An implementation of the interface is generated dynamically by the RestService, using HttpClient to make the external HTTP calls.
An interface and a reply are defined to represent the external API and its response:
public interface IHelloClient
    [Get("/helloworld")]
    Task<Reply> GetMessageAsync();
public class Reply
    public string Message { get; set; }
A typed client can be added, using Refit to generate the implementation:
public void ConfigureServices(IServiceCollection services)
    services.AddHttpClient("hello", c =>
        c.BaseAddress = new Uri("http://localhost:5000");
    .AddTypedClient(c => Refit.RestService.For<IHelloClient>(c));
    services.AddMvc();
The defined interface can be consumed where necessary, with the implementation provided by DI and Refit:
[ApiController]
public class ValuesController : ControllerBase
    private readonly IHelloClient _client;
    public ValuesController(IHelloClient client)
        _client = client;
    [HttpGet("/")]
    public async Task<ActionResult<Reply>> Index()
        return await _client.GetMessageAsync();
Outgoing request middleware
HttpClient already has the concept of delegating handlers that can be linked together for outgoing HTTP requests. The IHttpClientFactory makes it easy to define the handlers to apply for each named client. It supports registration and chaining of multiple handlers to build an outgoing request middleware pipeline. Each of these handlers is able to perform work before and after the outgoing request. This pattern is similar to the inbound middleware pipeline in ASP.NET Core. The pattern provides a mechanism to manage cross-cutting concerns around HTTP requests, including caching, error handling, serialization, and logging.
To create a handler, define a class deriving from DelegatingHandler. Override the SendAsync method to execute code before passing the request to the next handler in the pipeline:
public class ValidateHeaderHandler : DelegatingHandler
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
        if (!request.Headers.Contains("X-API-KEY"))
            return new HttpResponseMessage(HttpStatusCode.BadRequest)
                Content = new StringContent(
                    "You must supply an API key header called X-API-KEY")
        return await base.SendAsync(request, cancellationToken);
The preceding code defines a basic handler. It checks to see if an X-API-KEY header has been included on the request. If the header is missing, it can avoid the HTTP call and return a suitable response.
During registration, one or more handlers can be added to the configuration for an HttpClient. This task is accomplished via extension methods on the IHttpClientBuilder.
services.AddTransient<ValidateHeaderHandler>();
services.AddHttpClient("externalservice", c =>
    // Assume this is an "external" service which requires an API KEY
    c.BaseAddress = new Uri("https://localhost:5000/");
.AddHttpMessageHandler<ValidateHeaderHandler>();
In the preceding code, the ValidateHeaderHandler is registered with DI. The handler must be registered in DI as a transient service, never scoped. If the handler is registered as a scoped service and any services that the handler depends upon are disposable:
The handler's services could be disposed before the handler goes out of scope.
The disposed handler services causes the handler to fail.
Once registered, AddHttpMessageHandler can be called, passing in the handler type.
Multiple handlers can be registered in the order that they should execute. Each handler wraps the next handler until the final HttpClientHandler executes the request:
services.AddTransient<SecureRequestHandler>();
services.AddTransient<RequestDataHandler>();
services.AddHttpClient("clientwithhandlers")
    // This handler is on the outside and called first during the 
    // request, last during the response.
    .AddHttpMessageHandler<SecureRequestHandler>()
    // This handler is on the inside, closest to the request being 
    // sent.
    .AddHttpMessageHandler<RequestDataHandler>();
Use one of the following approaches to share per-request state with message handlers:
Pass data into the handler using HttpRequestMessage.Properties.
Use IHttpContextAccessor to access the current request.
Create a custom AsyncLocal storage object to pass the data.
Use Polly-based handlers
IHttpClientFactory integrates with a popular third-party library called Polly. Polly is a comprehensive resilience and transient fault-handling library for .NET. It allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.
Extension methods are provided to enable the use of Polly policies with configured HttpClient instances. The Polly extensions:
Support adding Polly-based handlers to clients.
Can be used after installing the Microsoft.Extensions.Http.Polly NuGet package. The package isn't included in the ASP.NET Core shared framework.
Handle transient faults
Most common faults occur when external HTTP calls are transient. A convenient extension method called AddTransientHttpErrorPolicy is included which allows a policy to be defined to handle transient errors. Policies configured with this extension method handle HttpRequestException, HTTP 5xx responses, and HTTP 408 responses.
The AddTransientHttpErrorPolicy extension can be used within Startup.ConfigureServices. The extension provides access to a PolicyBuilder object configured to handle errors representing a possible transient fault:
services.AddHttpClient<UnreliableEndpointCallerService>()
    .AddTransientHttpErrorPolicy(p => 
        p.WaitAndRetryAsync(3, _ => TimeSpan.FromMilliseconds(600)));
In the preceding code, a WaitAndRetryAsync policy is defined. Failed requests are retried up to three times with a delay of 600 ms between attempts.
Dynamically select policies
Additional extension methods exist which can be used to add Polly-based handlers. One such extension is AddPolicyHandler, which has multiple overloads. One overload allows the request to be inspected when defining which policy to apply:
var timeout = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(10));
var longTimeout = Policy.TimeoutAsync<HttpResponseMessage>(
    TimeSpan.FromSeconds(30));
services.AddHttpClient("conditionalpolicy")
// Run some code to select a policy based on the request
    .AddPolicyHandler(request => 
        request.Method == HttpMethod.Get ? timeout : longTimeout);
In the preceding code, if the outgoing request is an HTTP GET, a 10-second timeout is applied. For any other HTTP method, a 30-second timeout is used.
Add multiple Polly handlers
It's common to nest Polly policies to provide enhanced functionality:
services.AddHttpClient("multiplepolicies")
    .AddTransientHttpErrorPolicy(p => p.RetryAsync(3))
    .AddTransientHttpErrorPolicy(
        p => p.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));
In the preceding example, two handlers are added. The first uses the AddTransientHttpErrorPolicy extension to add a retry policy. Failed requests are retried up to three times. The second call to AddTransientHttpErrorPolicy adds a circuit breaker policy. Further external requests are blocked for 30 seconds if five failed attempts occur sequentially. Circuit breaker policies are stateful. All calls through this client share the same circuit state.
Add policies from the Polly registry
An approach to managing regularly used policies is to define them once and register them with a PolicyRegistry. An extension method is provided which allows a handler to be added using a policy from the registry:
var registry = services.AddPolicyRegistry();
registry.Add("regular", timeout);
registry.Add("long", longTimeout);
services.AddHttpClient("regulartimeouthandler")
    .AddPolicyHandlerFromRegistry("regular");
In the preceding code, two policies are registered when the PolicyRegistry is added to the ServiceCollection. To use a policy from the registry, the AddPolicyHandlerFromRegistry method is used, passing the name of the policy to apply.
Further information about IHttpClientFactory and Polly integrations can be found on the Polly wiki.
HttpClient and lifetime management
A new HttpClient instance is returned each time CreateClient is called on the IHttpClientFactory. There's an HttpMessageHandler per named client. The factory manages the lifetimes of the HttpMessageHandler instances.
IHttpClientFactory pools the HttpMessageHandler instances created by the factory to reduce resource consumption. An HttpMessageHandler instance may be reused from the pool when creating a new HttpClient instance if its lifetime hasn't expired.
Pooling of handlers is desirable as each handler typically manages its own underlying HTTP connections. Creating more handlers than necessary can result in connection delays. Some handlers also keep connections open indefinitely, which can prevent the handler from reacting to DNS changes.
The default handler lifetime is two minutes. The default value can be overridden on a per named client basis. To override it, call SetHandlerLifetime on the IHttpClientBuilder that is returned when creating the client:
services.AddHttpClient("extendedhandlerlifetime")
    .SetHandlerLifetime(TimeSpan.FromMinutes(5));
Disposal of the client isn't required. Disposal cancels outgoing requests and guarantees the given HttpClient instance can't be used after calling Dispose. IHttpClientFactory tracks and disposes resources used by HttpClient instances. The HttpClient instances can generally be treated as .NET objects not requiring disposal.
Keeping a single HttpClient instance alive for a long duration is a common pattern used before the inception of IHttpClientFactory. This pattern becomes unnecessary after migrating to IHttpClientFactory.
Alternatives to IHttpClientFactory
Using IHttpClientFactory in a DI-enabled app avoids:
Resource exhaustion problems by pooling HttpMessageHandler instances.
Stale DNS problems by cycling HttpMessageHandler instances at regular intervals.
There are alternative ways to solve the preceding problems using a long-lived SocketsHttpHandler instance.
Create an instance of SocketsHttpHandler when the app starts and use it for the life of the app.
Configure PooledConnectionLifetime to an appropriate value based on DNS refresh times.
Create HttpClient instances using new HttpClient(handler, disposeHandler: false) as needed.
The preceding approaches solve the resource management problems that IHttpClientFactory solves in a similar way.
The SocketsHttpHandler shares connections across HttpClient instances. This sharing prevents socket exhaustion.
The SocketsHttpHandler cycles connections according to PooledConnectionLifetime to avoid stale DNS problems.
Cookies
The pooled HttpMessageHandler instances results in CookieContainer objects being shared. Unanticipated CookieContainer object sharing often results in incorrect code. For apps that require cookies, consider either:
Disabling automatic cookie handling
Avoiding IHttpClientFactory
Call ConfigurePrimaryHttpMessageHandler to disable automatic cookie handling:
services.AddHttpClient("configured-disable-automatic-cookies")
    .ConfigurePrimaryHttpMessageHandler(() =>
        return new HttpClientHandler()
            UseCookies = false,
Logging
Clients created via IHttpClientFactory record log messages for all requests. Enable the appropriate information level in your logging configuration to see the default log messages. Additional logging, such as the logging of request headers, is only included at trace level.
The log category used for each client includes the name of the client. A client named MyNamedClient, for example, logs messages with a category of System.Net.Http.HttpClient.MyNamedClient.LogicalHandler. Messages suffixed with LogicalHandler occur outside the request handler pipeline. On the request, messages are logged before any other handlers in the pipeline have processed it. On the response, messages are logged after any other pipeline handlers have received the response.
Logging also occurs inside the request handler pipeline. In the MyNamedClient example, those messages are logged against the log category System.Net.Http.HttpClient.MyNamedClient.ClientHandler. For the request, this occurs after all other handlers have run and immediately before the request is sent out on the network. On the response, this logging includes the state of the response before it passes back through the handler pipeline.
Enabling logging outside and inside the pipeline enables inspection of the changes made by the other pipeline handlers. This may include changes to request headers, for example, or to the response status code.
Including the name of the client in the log category enables log filtering for specific named clients where necessary.
Configure the HttpMessageHandler
It may be necessary to control the configuration of the inner HttpMessageHandler used by a client.
An IHttpClientBuilder is returned when adding named or typed clients. The ConfigurePrimaryHttpMessageHandler extension method can be used to define a delegate. The delegate is used to create and configure the primary HttpMessageHandler used by that client:
services.AddHttpClient("configured-inner-handler")
    .ConfigurePrimaryHttpMessageHandler(() =>
        return new HttpClientHandler()
            AllowAutoRedirect = false,
            UseDefaultCredentials = true
Use IHttpClientFactory in a console app
In a console app, add the following package references to the project:
Microsoft.Extensions.Hosting
Microsoft.Extensions.Http
In the following example:
IHttpClientFactory is registered in the Generic Host's service container.
MyService creates a client factory instance from the service, which is used to create an HttpClient. HttpClient is used to retrieve a webpage.
The service's GetPage method is executed to write the first 500 characters of the webpage content to the console. For more information on calling services from Program.Main, see Dependency injection in ASP.NET Core.
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
class Program
    static async Task<int> Main(string[] args)
        var builder = new HostBuilder()
            .ConfigureServices((hostContext, services) =>
                services.AddHttpClient();
                services.AddTransient<IMyService, MyService>();
            }).UseConsoleLifetime();
        var host = builder.Build();
            var myService = host.Services.GetRequiredService<IMyService>();
            var pageContent = await myService.GetPage();
            Console.WriteLine(pageContent.Substring(0, 500));
        catch (Exception ex)
            var logger = host.Services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred.");
        return 0;
    public interface IMyService
        Task<string> GetPage();
    public class MyService : IMyService
        private readonly IHttpClientFactory _clientFactory;
        public MyService(IHttpClientFactory clientFactory)
            _clientFactory = clientFactory;
        public async Task<string> GetPage()
            // Content from BBC One: Dr. Who website (©BBC)
            var request = new HttpRequestMessage(HttpMethod.Get,
                "https://www.bbc.co.uk/programmes/b006q2x0");
            var client = _clientFactory.CreateClient();
            var response = await client.SendAsync(request);
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadAsStringAsync();
                return $"StatusCode: {response.StatusCode}";
Header propagation middleware
Header propagation is a community supported middleware to propagate HTTP headers from the incoming request to the outgoing HTTP Client requests. To use header propagation:
Reference the community supported port of the package HeaderPropagation. ASP.NET Core 3.1 and later supports Microsoft.AspNetCore.HeaderPropagation.
Configure the middleware and HttpClient in Startup:
public void ConfigureServices(IServiceCollection services)
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
    services.AddHttpClient("MyForwardingClient").AddHeaderPropagation();
    services.AddHeaderPropagation(options =>
        options.Headers.Add("X-TraceId");
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    if (env.IsDevelopment())
        app.UseDeveloperExceptionPage();
        app.UseHsts();
    app.UseHttpsRedirection();
    app.UseHeaderPropagation();
    app.UseMvc();
The client includes the configured headers on outbound requests:
var client = clientFactory.CreateClient("MyForwardingClient");
var response = client.GetAsync(...);
Additional resources
Use HttpClientFactory to implement resilient HTTP requests
Implement HTTP call retries with exponential backoff with HttpClientFactory and Polly policies
Implement the Circuit Breaker pattern