How do you use Basic Authentication with System.Net.Http.HttpClient?

It's not a good practice to create HttpClients explicitly from your calling code. Please use HttpClientFactory that simplifies a lot of things.

However, if you want to use basic authentication, just create an HttpRequestMessage and add the following header:

var request = new HttpRequestMessage(HttpMethod.Post, getPath)
{
    Content = new FormUrlEncodedContent(values)
};
request.Headers.Authorization = new BasicAuthenticationHeaderValue("username", "password");
// other settings

If you decide to use a recommended IHttpClientFactory it's even simpler:

serviceCollection.AddHttpClient(c =>
{
   c.BaseAddress = new Uri("your base url");
   c.SetBasicAuthentication("username", "password");
})

Don't encode the whole authentication string - encode the "Username:Password" expression and append the result to the "Basic " prefix.

var authenticationString = $"{clientId}:{clientSecret}";
var base64EncodedAuthenticationString = Convert.ToBase64String(Encoding.UTF8.GetBytes(authenticationString));
content.Headers.Add("Authorization", "Basic " + base64EncodedAuthenticationString);

Also, consider using just ASCII encoding - the UTF8 may not be understood by the server unless you add a charset declaration to the header.

Wikipedia seems to cover this quite well.

The specific problem is this line (below)

content.Headers.Add("Authorization", $"Basic {base64EncodedAuthenticationString}");

This fails because HttpContent.Headers (System.Net.Http.Headers.HttpContentHeaders) is only for headers that are content-specific, such as Content-Type, Content-Length, and so on.

You've stated that you can't use DefaultRequestHeaders because you only need it for a single request - but you also can't use it with PostAsync - only SendAsync provided you construct the HttpRequestMessage yourself, as per your own answer and @NeilMoss' answer - but you could use an extension-method in future.

But for the benefit of other readers, another alternative is to add a new extension method based on the existing PostAsync, which is actually really simple (only 3 lines!):

public Task<HttpResponseMessage> PostAsync( this HttpClient httpClient, Uri requestUri, HttpContent content, String basicUserName, String basicPassword, String? challengeCharSet = null, CancellationToken cancellationToken = default )
{
    if( basicUserName.IndexOf(':') > -1 ) throw new ArgumentException( message: "RFC 7617 states that usernames cannot contain colons.", paramName: nameof(basicUserName) );

    HttpRequestMessage httpRequestMessage = new HttpRequestMessage( HttpMethod.Post, requestUri );
    httpRequestMessage.Content = content;

    //

    Encoding encoding = Encoding.ASCII;
    if( challengeCharSet != null )
    {
        try
        {
            encoding = Encoding.GetEncoding( challengeCharSet );
        }
        catch
        {
            encoding = Encoding.ASCII;
        }
    }

    httpRequestMessage.Headers.Authorization = new AuthenticationHeaderValue(
        scheme   : "Basic",
        parameter: Convert.ToBase64String( encoding.GetBytes( userName + ":" + password ) )
    );

    return httpClient.SendAsync( httpRequestMessage, cancellationToken );
}

Usage:

HttpClient httpClient = ...

using( HttpResponseMessage response = await httpClient.PostAsync( uri, content, basicUserName: "AzureDiamond", basicPassword: "hunter2" ).ConfigureAwait(false) )
{
    // ...
}

Using .NET 6, I use the HttpClient.DefaultRequestHeaders.Authorization property to set the Authorization header.

// This example will send a signing request to the RightSignature API
var api = "https://api.rightsignature.com/public/v2/sending_requests";

// requestJson is the serialized JSON request body
var contentData = new StringContent(requestJson, Encoding.UTF8, "application/json");

// Instantiate client (for testing), use Microsoft's guidelines in production
var client = new HttpClient();

// Use basic auth, the token has already been converted to base64
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", tokenB64);

try
{
    var response = await client.PostAsync(api, contentData);
}
...

Good luck!

Just something to add that I struggled with, which I only experienced with Basic authentication endpoints. If you add Json as StringContent then it adds a charset=utf-8, this often return a BadRequest 400.

Here is the code I got to fix this: reference: https://dzone.com/articles/httpclient-how-to-remove-charset-from-content-type

using (var client = new HttpClient())
using (var content = new StringContent(ParseJSON(data), Encoding.Default, "application/json"))
{  
   //Remove UTF-8 Charset causing BadRequest 400
   content.Headers.ContentType.CharSet = "";

   var clientId = "client";
   var clientSecret = "secret";
   var authenticationString = $"{clientId}:{clientSecret}";
   var base64EncodedAuthenticationString = Convert.ToBase64String(System.Text.ASCIIEncoding.UTF8.GetBytes(authenticationString));
   client.DefaultRequestHeaders.TryAddWithoutValidation(authHeader, authorization);

   var response = await client.PostAsync(url, content);
   return response;
}

I have resolve this by using below code, that serve my purpose also. Added Code for both Get/Post, this will help you. Moreover I have added one more Header key. So to pass extra data to header. Hope that will resolve your issue.

class Program 
{
    private static readonly string Username = "test";
    private static readonly string Password = "test@123";
    
    static void Main(string[] args) 
    {
        var response = Login();
    }
    
    public static async Task Login() 
    {
        var anotherKey ="test";
        HttpClient httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://google.com/")
        };

        httpClient.DefaultRequestHeaders.Add($"Authorization", $"Basic {Base64Encode($"{Username}:{Password}")}");
        httpClient.DefaultRequestHeaders.Add($"anotherKey", $"{anotherKey}");
        HttpResponseMessage httpResponseMessage = await httpClient.GetAsync("user/123").ConfigureAwait(false);
        // For Get Method
        var response= await httpResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
        // For Post Method
        User user = new User (1,"ABC");
        HttpResponseMessage httpResponseMessage = await httpClient.PostAsJsonAsync("/post", user).ConfigureAwait(false);
        UserDetail userDetail  = await httpResponseMessage.Content.ReadAsAsync<UserDetail>().ConfigureAwait(false);
    }
}

This code works on .NET 8. Although, if it works on .NET 8 there's a good chance you never make it to this question :)

    string clientId = Util.GetPassword("spotify_clientid");
    string clientSecret = Util.GetPassword("spotify_clientsecret");

    byte[] basicBytes = Encoding.ASCII.GetBytes($"{clientId}:{clientSecret}");
    string basicB64 = Convert.ToBase64String(basicBytes);

    basicB64.Dump();
    
    string authUri = "https://accounts.spotify.com/api/token";

    var kvp = new Dictionary<string, string>
    {
        {"grant_type", "client_credentials" }
    };

    var http = new HttpClient();
    http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue($"Basic", basicB64);

    HttpResponseMessage res = await http.PostAsync(authUri, new FormUrlEncodedContent(kvp));

    res.StatusCode.Dump("status code");

    string content = await res.Content.ReadAsStringAsync();

    content.Dump("content");