Custom header to HttpClient request

Question

How do I add a custom header to a HttpClient request? I am using PostAsJsonAsync method to post the JSON. The custom header that I would need to be added is

"X-Version: 1"

This is what I have done so far:

using (var client = new HttpClient()) {
    client.BaseAddress = new Uri("https://api.clickatell.com/");
    client.DefaultRequestHeaders.Accept.Clear();
    client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "xxxxxxxxxxxxxxxxxxxx");
    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
    var response = client.PostAsJsonAsync("rest/message", svm).Result;
}

Solution 1

var request = new HttpRequestMessage {
    RequestUri = new Uri("[your request url string]"),
    Method = HttpMethod.Post,
    Headers = {
        { "X-Version", "1" } // HERE IS HOW TO ADD HEADERS,
        { HttpRequestHeader.Authorization.ToString(), "[your authorization token]" },
        { HttpRequestHeader.ContentType.ToString(), "multipart/mixed" },//use this content type if you want to send more than one content type
    },
    Content = new MultipartContent { // Just example of request sending multipart request
        new ObjectContent<[YOUR JSON OBJECT TYPE]>(
            new [YOUR JSON OBJECT TYPE INSTANCE](...){...}, 
            new JsonMediaTypeFormatter(), 
            "application/json"), // this will add 'Content-Type' header for the first part of request
        new ByteArrayContent([BINARY DATA]) {
            Headers = { // this will add headers for the second part of request
                { "Content-Type", "application/Executable" },
                { "Content-Disposition", "form-data; filename=\"test.pdf\"" },
            },
        },
    },
};

Solution 2

I have found the answer to my question.

client.DefaultRequestHeaders.Add("X-Version","1");

That should add a custom header to your request

Solution 3

Here is an answer based on that by Anubis (which is a better approach as it doesn't modify the headers for every request) but which is more equivalent to the code in the original question:

using Newtonsoft.Json;
...

var client = new HttpClient();
var httpRequestMessage = new HttpRequestMessage
    {
        Method = HttpMethod.Post,
        RequestUri = new Uri("https://api.clickatell.com/rest/message"),
        Headers = { 
            { HttpRequestHeader.Authorization.ToString(), "Bearer xxxxxxxxxxxxxxxxxxx" },
            { HttpRequestHeader.Accept.ToString(), "application/json" },
            { "X-Version", "1" }
        },
        Content = new StringContent(JsonConvert.SerializeObject(svm))
    };

var response = client.SendAsync(httpRequestMessage).Result;

Solution 4

There is a Headers property in the HttpRequestMessage class. You can add custom headers there, which will be sent with each HTTP request. The DefaultRequestHeaders in the HttpClient class, on the other hand, sets headers to be sent with each request sent using that client object, hence the name Default Request Headers.

Hope this makes things more clear, at least for someone seeing this answer in future.

Solution 5

I have added x-api-version in HttpClient headers as below :

var client = new HttpClient(httpClientHandler)
{
    BaseAddress = new Uri(callingUrl)
};
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("x-api-version", v2);

View more solutions

Comments

[Liam]

Possible duplicate of Adding Http Headers to HttpClient

[Libin Joseph]

@Liam : My question was how to add custom headers. Where as the other question was how to add headers

[Don Rolling]

I think it has been found that we shouldn't dispose of HttpClient. aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong

[Ruhrpottpatriot]

No, it does not. This answer should be viewed with caution, since the defaults request headers are sent with each request. You should build your request like @Anubis suggested. DefaultsRequestHeaders should be populated when you create the HttpClient.

[kamilk]

This only works because you are instantiating a new HttpClient for every request. This is not the way this class should be used: it should be a static field, reused for all requests, at least those to the same endpoint. See documentation and countless blog posts out there. Then, as of course, as @Ruhrpottpatriot points out, changing default headers will affect all requests.

[heug]

answer is extremely confusing ... why are you bringing in code for documents, blank.pdf, etc? instantiating bytearray classes to pass custom headers within the Content param?

[Anubis]

@heug Well. If you are looking for header you can see it. Content is present here in order to complete the picture because you most likely want to add some content to your request. And in order to not be tedious the content is complicated and contain both JSON and binary data.

[heug]

it just seems more straightfoward to do it like this: create StringContent using your content JSON, create a HTTP message with your method and URI, then add headers like message.Headers.Add("x":"y") .... then pass those into a response var like "var response = await httpClient.SendAsync(message);"

[Anubis]

@heug I will remember this for the furute. Thanks!

[joedotnot]

No, does not make it any clearer. In both cases you are saying you are sending headers on every request - So what is the difference?

[Ross Presser]

Headers is a property of an individual HttpRequestMessage object. Thus you can create different messages with different headers. DefaultRequestHeaders is a property of the HttpClient object; if multiple messages are sent through a given HttpClient, all such messages will all have the same DefaultRequestHeaders added to the message's individual headers.

[Panagiotis Kanavos]

@RossPresser definitely not. Content-Type is a Content header.

[Ron]

Which line in the above accepted answer actually implements the header that the OP requested, X-Version? Why is this considered the accepted answer?

[Ron]

Agreed this is the answer. It demonstrates how to add the header that OP requested. Answered my question as well.

[David Klempfner]

@Ruhrpottpatriot What's wrong with sending the header for every request?

[Ruhrpottpatriot]

@Backwards_Dave See the comment directly above yours

[ajbeaven]

@kamilk Microsoft's docs specifically recommend disposing the HttpClient after each use, so there's nothing wrong with this. docs.microsoft.com/en-us/dotnet/api/…

[kamilk]

@ajbeaven Nope, that's not what it says. The example at the top of the page shows the Main method of the app, so even though the HttpClient is disposed of, the same instance is used throughout the lifetime of the application, and that is correct in regards to what the documentation says a little bit further down: 'HttpClient is intended to be instantiated once and re-used throughout the life of an application'. Following this paragraph is an example recommending assigning an HttpClient to a static field.

[ajbeaven]

@kamilk, you're dead right - that example put me wrong. Thanks for putting me right :)

[Tom Anderson]

Adding a header to the default headers does not instantiate a new HttpClient, it merely adds another header. To remove the header, use client.DefaultRequestHeaders.Remove("X-Version"); (or client.DefaultRequestHeaders.Clear() to remove all).

[Mass Dot Net]

FYI I think HttpRequestHeader.Access should be HttpRequestHeader.Accept.

[aswzen]

what is svm by the way?

[Chris Peacock]

@aswzen It's from the OP's question - something model I would guess. The object being serialised.

[Anubis]

Sorry. I had to prittify my answer long ago. Hope it is less confusing now.

[FARHAD AFSAR]

really why? why making a HTTP request with c# has to be more difficult than c or more difficult than do it with a simple TCP socket? all this headers will gather in payload as simple string and lines, so i think this much of classes and abstracts are just waste of time.

[Kzrbill]

Use DefaultRequestHeaders for your app's "global" instance of HttpClient only. "HttpClient is intended to be instantiated once per application" docs.microsoft.com/en-us/dotnet/api/…. Better to use HttpRequestMessage as described in @Chris Peacock's answer above for granular customisation of specific http request. Both approaches are valid its just HttpRequestMessage gives better control without adverse side effects to other consumers of you client unless DefaultRequestHeaders are really intended to be just that.

[Jerameel Resco]

Using the code snippet Chris Peacock provided works for me. The same question scenario I had with the OP. Used the HttpRequestMessage class as well and the SendAsync() method.

[Alex]

+1 But still you shouldn't create new HttpClient-instances for every request, this answer could misdirect users in that aspect.

[Chris Peacock]

@Alex yes, agreed. This was just supposed to be a self-contained example that related easily to the OP's question.

[Psddp]

Since DefaultRequestHeaders is not thread safe, you shouldn't use it if you care about paralellism: docs.microsoft.com/en-us/dotnet/api/…

[Saad Khan]

It is mentioned in the documentation that you should instantiate HTTPClient only once per application and should not create a new instance for every request. What is the reason for this recommendation? What is the disadvantage?

[Alex from Jitbit]

Is is ok to use this answer if you're instantiating httpclient using HttpClientFactory?

[Alex from Jitbit]

I found this answer really helpful, thanks for the extra examples.