HTTP Header Analyzer

Paste raw HTTP request or response headers to inspect security, caching, CORS, content, and auth metadata. Descriptions for 88 headers, with hints. Runs in your browser.

  • Runs in your browser
  • Tool input is not uploaded to ZeroTool servers
  • Free · No Sign-Up
Analyze detects the message type, groups headers and shows configuration hints. After editing, click Analyze again to refresh the result. Choose a sample response, authenticated request or CORS preflight. It replaces the input and runs Analyze immediately. Clear removes the input, result and status. Ctrl or Command + L does the same while focus is inside this tool. Copy JSON exports the complete last analyzed result, whichever view is selected. Editing input alone does not update that result.
Paste request or response headers, optionally starting with a method or status line. HTTP/2 and HTTP/3 pseudo-headers are supported; no URL is fetched. Output of curl -i or curl -v can be pasted as it is: the body is not read, and with several messages the last response is analyzed.

Header categories, hints and JSON will appear here.

Results and copied JSON keep Authorization and Cookie values. Review them before sharing.

Read the full guide Read HTTP Headers Like a Pro: A Practical Guide
Examples, details and FAQ Worked examples, how it compares with other tools, and answers to common questions.

Example: Response with security headers

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Strict-Transport-Security: max-age=63072000; includeSubDomains; preload
Content-Security-Policy: default-src 'self'; script-src 'self'
X-Content-Type-Options: nosniff
Referrer-Policy: strict-origin-when-cross-origin
Cache-Control: no-store
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Strict; Path=/

The analyzer groups Strict-Transport-Security, Content-Security-Policy, X-Content-Type-Options, and Referrer-Policy under Security. Cache-Control lands in Caching, Content-Type in Content, and Set-Cookie in Cookie. Each card includes a one-line description and any hints — for example, a Set-Cookie without HttpOnly triggers a warning.

Example: CORS preflight

OPTIONS /api/v1/orders HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Access-Control-Request-Method: POST
Access-Control-Request-Headers: Authorization, Content-Type

This is recognized as a request, and the Access-Control-Request-* pair marks it as a preflight. Origin and both Access-Control-Request-* headers are listed under CORS; Host is under General. Copy JSON gives:

{
  "_status": "OPTIONS /api/v1/orders HTTP/1.1",
  "host": "api.example.com",
  "origin": "https://app.example.com",
  "access-control-request-method": "POST",
  "access-control-request-headers": "Authorization, Content-Type"
}

Paste the server's answer to the preflight next to it to see whether the Access-Control-Allow-* values cover the requested method and headers; the tool does not compare the two messages for you.

Categories at a glance

  • Status — the first line (status line or method line).
  • Lines not read as headers — lines that are not header field lines, for example without a colon, with the line number and the reason. They are left out of the count, the Raw view and the JSON.
  • Security — HSTS, CSP, X-Frame-Options, COOP/COEP/CORP, Permissions-Policy, fetch metadata.
  • Caching — Cache-Control, ETag, Vary, Expires, Last-Modified, conditional headers.
  • Content — Content-Type, Content-Encoding, Accept-*, Content-Disposition.
  • CORS — Access-Control-* and Origin.
  • Auth — Authorization, WWW-Authenticate, Proxy-Authenticate.
  • Cookie — Cookie and Set-Cookie.
  • Transport / Range / Proxy / General / Custom — the rest, with X-* unknown headers in Custom.

Configuration hints

Hints are conservative — they highlight obvious misconfiguration, not subjective style. Examples:

  • HSTS max-age below 1 year, or missing includeSubDomains / preload directives.
  • CSP containing 'unsafe-eval', or 'unsafe-inline' in a directive without a nonce or hash.
  • Set-Cookie without HttpOnly or Secure flags.
  • Access-Control-Allow-Credentials: true paired with a wildcard origin (spec-illegal).
  • Cache-Control combining no-store with max-age (dead weight).

Example: a response with problems

Pasting the following response, copied from an HTTP/2 site, produces the hints listed under it. The hint texts are quoted from the tool's output.

HTTP/2 200
content-type: text/html; charset=utf-8
strict-transport-security: max-age=86400
content-security-policy: script-src 'self' 'unsafe-inline'
access-control-allow-origin: *
access-control-allow-credentials: true
set-cookie: sid=31d4d96e407aad42; Path=/
cache-control: no-store, max-age=600
server: nginx

The categorized view shows these hints, card by card:

strict-transport-security
  Warning: max-age < 1 year (31536000s). Many preload lists require ≥ 1 year.
  Note: Add includeSubDomains for full coverage.
  Note: Add preload and submit to hstspreload.org.
content-security-policy
  Warning: 'unsafe-inline' defeats most XSS protection. Use nonces or hashes instead.
  Note: No default-src — define one as a safety net.
cache-control
  Warning: no-store and max-age together — no-store wins, max-age is dead weight.
access-control-allow-origin
  Note: Wildcard origin disables credentialed CORS by spec.
access-control-allow-credentials
  Warning: Credentialed CORS requires explicit Allow-Origin (no wildcard).
set-cookie
  Warning: Missing HttpOnly — cookie is reachable from JavaScript.
  Warning: Missing Secure — cookie can be sent over plain HTTP.
  Note: No SameSite — Chrome treats the cookie as Lax, Firefox and Safari do not. Set it explicitly.
server
  Note: Exposing server software helps attackers fingerprint the stack. Consider suppressing.
  • strict-transport-security: Warning “max-age < 1 year (31536000s). Many preload lists require ≥ 1 year.”, plus notes to add includeSubDomains and preload. One day (86400 s) is far below the one year that hstspreload.org requires.
  • content-security-policy: Warning “'unsafe-inline' defeats most XSS protection. Use nonces or hashes instead.” and a note that there is no default-src.
  • access-control-allow-credentials: Warning “Credentialed CORS requires explicit Allow-Origin (no wildcard).” The Fetch Standard does not let a browser expose a credentialed response when the origin is *. The warning disappears when the pasted headers contain a specific origin such as https://app.example.com.
  • set-cookie: Warnings for missing HttpOnly and Secure, and a note for the missing SameSite attribute: Chrome treats such a cookie as SameSite=Lax, while Firefox and Safari do not (MDN browser compatibility data), so the behaviour differs between browsers.
  • cache-control: Warning that no-store makes max-age=600 pointless.
  • server: A note that the software name helps fingerprinting.

The summary bar shows the message type (response), the status line, the number of headers and how many fall in the Security group. A response with no security headers at all gets a warning in the summary instead.

Where to copy headers from

  • curl: curl -sS -D - -o /dev/null https://example.com/ prints the response headers of a normal GET. curl -i prints the body after them; you can paste it as it is, because the tool stops at the empty line. curl -I sends a HEAD request, which some servers answer with different headers.
  • Chrome or Edge DevTools: Network panel → select the request → Headers → turn on Raw next to Response Headers or Request Headers, then copy.
  • Firefox DevTools: Network panel → select the request → Headers → turn on the Raw switch.

If you need the full request list with timings and bodies, export a HAR file and open it in the HAR analyzer below instead.

Limitations

The summary counts only the first Strict-Transport-Security field; ignored duplicates remain in the results and JSON. Trailing spaces and tabs are removed from the analyzed start line in every result view. A line containing only spaces or tabs currently ends a section just like an empty line; it is not joined to the preceding value. The analyzer supports the nine request methods listed below. If the analyzed message starts with another method, the request line is listed under “Lines not read as headers” with an unsupported-method explanation. This also applies to absolute URLs and other targets containing colons: the request line is excluded from Raw, JSON and Copy JSON, while the following headers are still read. Diagnostic line numbers refer to the original input. This is an analyzer limitation, not a method validity check.

For example, the unsupported PROPFIND start line below is excluded, while Host and both X-Trace values are retained in JSON:

PROPFIND http://example.test/a HTTP/1.1
Host: example.test
X-Trace: one
X-Trace: two
{
  "host": "example.test",
  "x-trace": [
    "one",
    "two"
  ]
}
  • The descriptions and hint texts are in English on every language version of this page. 88 headers have a description; any other header is listed under Custom / Other without one.
  • HTTP/2 and HTTP/3 pseudo-headers such as :status and :path, which browser developer tools copy as the first lines, are listed in their own group with a short description (RFC 9113 §8.3, RFC 8441 for :protocol). Without a status line, :status marks the input as a response and :method as a request.
  • The supported request methods are GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD, TRACE and CONNECT, written in uppercase. Method names are case-sensitive (RFC 9110 section 9.1), so get / HTTP/1.1 is listed under “Lines not read as headers” with a note. Unsupported request start lines such as PROPFIND http://example.test/a HTTP/1.1 are also listed there with an unsupported-method explanation; they are never exported as header fields.
  • One message is analyzed. A header section ends at an empty line (RFC 9112 section 2.1). If the next line is a status line or request line, it starts another message: curl -v gives the request and then the response, curl -iL gives one response per redirect. The tool analyzes the last response, lists the other messages under “Other messages in the input” and says so in the status line. Any other line after an empty line ends the reading, and the status line says how many lines were not read. The tool skips the * lines and data lines such as } [5 bytes data], and removes a leading > or < .
  • A line that is not a header field line, such as one without an ASCII colon or with a full-width colon (Content-Type:text/html), is not counted. It is listed under “Lines not read as headers” with its line number and the reason, and the status line gives the count. A line with whitespace between the name and the colon is listed there too, because RFC 9112 section 5.1 does not allow it (a server must reject such a request with 400).
  • The HSTS check reads max-age as digits or as a quoted value such as max-age="31536000", which RFC 6797 section 6.1 allows. When a response has more than one Strict-Transport-Security header, only the first is checked; the others get a note that browsers ignore them (RFC 6797 section 8.1).
  • The 'unsafe-inline' check works per directive. When the same directive also has a nonce or hash, browsers that support CSP Level 2 or later ignore 'unsafe-inline' (CSP Level 3 section 6.7.3.2), so the tool shows a note instead of the warning; this is the usual fallback for old browsers in a strict policy. style-src 'unsafe-inline' without a nonce or hash still gets the warning, whose text is about scripts. 'strict-dynamic' on its own is not taken into account.
  • Hints look at one header at a time, except the CORS credentials check above. The tool does not evaluate a full CSP (use the CSP Header Generator) and does not check cookie attributes beyond HttpOnly, Secure and SameSite.
  • The JSON view uses lowercase names, because header names are case-insensitive (RFC 9110 section 5.1), and puts repeated headers into arrays.
  • Nothing is fetched: the tool cannot see redirects or headers you did not paste. Because pasted headers often contain cookies and tokens, this page does not load Google Analytics or AdSense, and the input is not saved.

Related tools on ZeroTool

FAQ

Does this tool send my headers to a server?

No. The headers are parsed by the page script in your browser and are not uploaded or saved. Because pasted headers often hold cookies and tokens, this page does not load Google Analytics or AdSense. The result and Copy JSON keep Authorization and Cookie values as pasted, so check them before you share the output.

Can it fetch headers from a URL?

No. Nothing is fetched; the tool reads only what you paste. Copy the headers from curl -sS -D - -o /dev/null URL, curl -i, curl -v or the Raw view of the browser DevTools Network panel. The tool skips the * lines of curl -v, removes its > and < prefixes and stops at the empty line before a body. When the input holds several messages (the curl -v request and response, or the redirects of curl -iL), it analyzes the last response and lists the others.

How does it detect request vs response?

It reads the first line. HTTP/x.x at the start is a response. One of GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD, TRACE or CONNECT, in uppercase, followed by a target and HTTP/x.x is a request. Otherwise a :status pseudo-header makes it a response and :method a request; if there is neither, the input is treated as header lines only.

What security headers does it check?

Hints check the values of Strict-Transport-Security, Content-Security-Policy, Set-Cookie (HttpOnly, Secure, SameSite), X-Frame-Options, X-XSS-Protection and the CORS Allow-Origin / Allow-Credentials pair. X-Content-Type-Options, Referrer-Policy, Permissions-Policy, the Cross-Origin-* headers and fetch metadata get a description and count toward the security total in the summary, but their values are not checked.

How does it handle duplicate headers and folded lines?

Each line stays a separate card in the categorized view and a separate line in the Raw view. The JSON view puts repeated names into an array in input order; names are compared without regard to case. A line that starts with a space or tab (obs-fold, RFC 9112 section 5.2) is joined to the previous header with one space.

Can I export the parsed result?

Yes. Copy JSON copies the result of the last Analyze, whichever view is open. Keys are lowercase header names, a header that appears once has a string value, a repeated header has an array, and the first line is under _status.