<p>How do I access a page's HTTP response headers via JavaScript?</p>

<p>Related to <a href="https://stackoverflow.com/questions/220149/how-do-i-access-the-http-request-header-fields-via-javascript"><strong>this question</strong></a>, which was modified to ask about accessing two specific HTTP headers.</p>

<blockquote>
  <p><strong>Related:</strong><br>
  <a href="https://stackoverflow.com/questions/220149/how-do-i-access-the-http-request-header-fields-via-javascript">How do I access the HTTP request header fields via JavaScript?</a></p>
</blockquote>

Unfortunately, there isn't an API to give you the HTTP response headers for your initial page request. That was the original question posted here. It has been
repeatedly asked
, too, because some people would like to get the actual response headers of the original page request without issuing another one.
For AJAX Requests:
If an HTTP request is made over AJAX, it is possible to get the response headers with the
```
getAllResponseHeaders()
```
method. It's part of the XMLHttpRequest API. To see how this can be applied, check out the
```
fetchSimilarHeaders()
```
function below. Note that this is a work-around to the problem that won't be reliable for some applications.
```
```
myXMLHttpRequest.getAllResponseHeaders();
```
```
The API was specified in the following candidate recommendation for XMLHttpRequest:
XMLHttpRequest - W3C Candidate Recommendation 3 August 2010
Specifically, the
```
getAllResponseHeaders()
```
method was specified in the following section:
w3.org:
```
XMLHttpRequest
```
: the
```
getallresponseheaders()
```
method
The MDN documentation is good, too:
developer.mozilla.org:
```
XMLHttpRequest
```
.
This will not give you information about the original page request's HTTP response headers, but it could be used to make educated guesses about what those headers were. More on that is described next.
Getting header values from the Initial Page Request:
This question was first asked several years ago, asking specifically about how to get at the original HTTP response headers for the
current page
(i.e. the same page inside of which the javascript was running). This is quite a different question than simply getting the response headers for any HTTP request. For the initial page request, the headers aren't readily available to javascript. Whether the header values you need will be reliably and sufficiently consistent if you request the same page again via AJAX will depend on your particular application.
The following are a few suggestions for getting around that problem.
1. Requests on Resources which are largely static
If the response is largely static and the headers are not expected to change much between requests, you could make an AJAX request for the same page you're currently on and assume that they're they are the same values which were part of the page's HTTP response. This could allow you to access the headers you need using the nice XMLHttpRequest API described above.
```
```
function fetchSimilarHeaders (callback) {
    var request = new XMLHttpRequest();
    request.onreadystatechange = function () {
        if (request.readyState === XMLHttpRequest.DONE) {
            //
            // The following headers may often be similar
            // to those of the original page request...
            //
            if (callback && typeof callback === 'function') {
                callback(request.getAllResponseHeaders());
            }
        }
    };

    //
    // Re-request the same page (document.location)
    // We hope to get the same or similar response headers to those which 
    // came with the current page, but we have no guarantee.
    // Since we are only after the headers, a HEAD request may be sufficient.
    //
    request.open('HEAD', document.location, true);
    request.send(null);
}
```
```
This approach will be problematic if you truly have to rely on the values being consistent between requests, since you can't fully guarantee that they are the same. It's going to depend on your specific application and whether you know that the value you need is something that won't be changing from one request to the next.
2. Make Inferences
There are
some BOM properties
(Browser Object Model) which the browser determines by looking at the headers. Some of these properties reflect HTTP headers directly (e.g.
```
navigator.userAgent
```
is set to the value of the HTTP
```
User-Agent
```
header field). By sniffing around the available properties you might be able to find what you need, or some clues to indicate what the HTTP response contained.
3. Stash them
If you control the server side, you can access any header you like as you construct the full response. Values could be passed to the client with the page, stashed in some markup or perhaps in an inlined JSON structure. If you wanted to have every HTTP request header available to your javascript, you could iterate through them on the server and send them back as hidden values in the markup. It's probably not ideal to send header values this way, but you could certainly do it for the specific value you need. This solution is arguably inefficient, too, but it would do the job if you needed it.