Your files never leave your device. All processing happens locally in your browser.
How do I check a website’s HTTP security, SEO and caching headers without uploading anything?
Open AnyTool’s HTTP Header Checker, get your page’s response headers — run curl -I https://your-site.com in a terminal, or open DevTools → Network → click the document request → Response Headers — and paste them in. The tool parses them (case-insensitively, handling the HTTP status line, duplicate headers and curl -I output) and analyzes them in four groups: SECURITY against the OWASP Secure Headers set (Strict-Transport-Security / HSTS, Content-Security-Policy, X-Frame-Options or CSP frame-ancestors, X-Content-Type-Options: nosniff, Referrer-Policy, Permissions-Policy and the Cross-Origin isolation trio, plus penalties for the deprecated X-XSS-Protection and the leaky Server / X-Powered-By headers); SEO (a header-level X-Robots-Tag noindex is flagged PROMINENTLY because it removes the URL from search, plus Link rel=canonical, Content-Type + charset, Content-Language and Vary); and CACHING (Cache-Control, ETag / Last-Modified validators and Content-Encoding compression). Each header gets a present-with-strength or missing-with-fix card, and the key security headers roll up into a 0–100 security score with an A–F grade. Everything runs in your browser, so your headers are never uploaded. A browser cannot read another site’s response headers directly (CORS blocks cross-origin header access) and there is no server proxy, so paste them from curl / DevTools; this checks best practices, it is not a full penetration test — verify with securityheaders.com or Mozilla Observatory.
Paste response headers from curl -I or DevTools → Response Headers — nothing is uploaded
Four groups: Security (OWASP), SEO, Caching, Server — each header present-with-strength or missing-with-fix
PROMINENTLY flags a header-level X-Robots-Tag noindex (it removes the URL from search results)
0–100 security score + A–F grade from the strength of the key security headers
100% client-side — a browser can’t read cross-origin headers (paste them); it’s guidance, not a pentest
What is
HTTP response header security check
HTTP response headers are the metadata a server sends alongside a page that tell the browser how to treat the response. A subset of them harden security: Strict-Transport-Security (HSTS) forces HTTPS; Content-Security-Policy restricts where scripts, styles and frames may load from (the main XSS defence); X-Frame-Options or CSP frame-ancestors stop clickjacking; X-Content-Type-Options: nosniff blocks MIME sniffing; Referrer-Policy limits referrer leakage; Permissions-Policy disables unused browser features; and the Cross-Origin-Opener / Embedder / Resource-Policy headers isolate the page from cross-origin attacks. Others affect SEO (X-Robots-Tag can noindex a URL at the HTTP layer; Link rel=canonical, Content-Type, Content-Language, Vary) or performance (Cache-Control, ETag / Last-Modified, Content-Encoding compression). Checking these headers means comparing what a server actually returns against the OWASP Secure Headers recommendations and SEO / caching best practice, and identifying which are present-and-strong, weak, or missing.
Because a browser cannot read another site’s HTTP response headers — cross-origin header access is blocked by CORS — and we use no server proxy, so we can’t fetch them for you. Paste them from curl -I or DevTools.
Reading a response’s headers cross-origin is deliberately restricted by the browser’s Same-Origin Policy and CORS: JavaScript on our page can only see a handful of “safelisted” response headers from a different origin, and essentially none of the security headers you care about. Many tools work around this with a server-side proxy that fetches the URL for you — but that means sending your URL (and your site’s configuration) to their server. We deliberately don’t do that, which is what keeps everything private and lets you check staging or internal sites. So the reliable path is to get the headers yourself: run curl -I https://your-site.com (or curl -sD - -o /dev/null https://your-site.com) in a terminal, or open DevTools → Network, reload, click the top document request and copy the Response Headers — then paste them in. The optional “try to fetch” box only demonstrates the CORS limit.
The presence and strength of the key OWASP security headers — HSTS, CSP, X-Content-Type-Options, X-Frame-Options / frame-ancestors, Referrer-Policy, Permissions-Policy and the Cross-Origin trio — minus penalties for deprecated or leaky headers.
The 0–100 security score is a weighted roll-up of the key security headers. The biggest weights go to Strict-Transport-Security (HSTS) and Content-Security-Policy, then X-Frame-Options (or CSP frame-ancestors) and X-Content-Type-Options: nosniff, then Referrer-Policy, Permissions-Policy and the Cross-Origin-Opener / Resource-Policy headers. Each contributes proportionally to how strong its value is — for example HSTS scores higher with a one-year+ max-age plus includeSubDomains, and CSP scores lower if it relies on unsafe-inline / unsafe-eval. Small penalties are subtracted for advertising the deprecated X-XSS-Protection or leaking your stack via Server (with a version) and X-Powered-By, which OWASP recommends removing. The result maps to an A–F grade with a plain-language verdict. It reflects header hygiene against best practice, not a guarantee — it’s guidance, not a penetration test.
Yes. It flags a header-level X-Robots-Tag noindex prominently, and checks Link rel=canonical, Content-Type + charset, Content-Language, Vary, Cache-Control, ETag / Last-Modified and Content-Encoding compression.
The report has four groups. Security is the OWASP set. SEO covers the headers a crawler reads: it flags a header-level X-Robots-Tag noindex or nofollow PROMINENTLY (a header noindex overrides any index meta tag and removes the URL from search), and checks the Link rel=canonical (the way to canonicalize non-HTML files like PDFs), Content-Type with a declared charset, Content-Language and Vary. Caching / performance covers Cache-Control (long-cache fingerprinted assets, revalidate HTML), the ETag / Last-Modified validators that enable cheap 304 revalidation, and Content-Encoding (gzip / brotli / zstd compression). A fourth Server group surfaces fingerprinting headers to minimize (Server, X-Powered-By) and any redirect Location. Each header has its own card with the value found and a concrete fix.
No. The headers you paste are parsed and analyzed entirely in your browser with plain JavaScript — nothing is uploaded, logged or stored, so it’s safe for staging or internal sites.
The HTTP Header Checker is 100% client-side. The headers you paste are parsed and checked locally in your browser; nothing is fetched, uploaded, logged or stored on a server, and no site is ever contacted (there is deliberately no server proxy). Unlike online header scanners that fetch your URL server-side — exposing which URL you’re testing and its configuration — this is safe for staging, internal or pre-launch sites whose headers you don’t want to send to a third party. It works offline once cached as a PWA, and closing the tab discards everything you entered. It is honest about scope: it only sees the headers you paste (not your TLS config, cookie flags or runtime behaviour), so treat it as best-practice guidance and confirm with your server config plus a dedicated scanner like securityheaders.com or Mozilla Observatory.
Detailed Explanation
📖How It Works
What the HTTP Header Checker Analyzes
The HTTP Header Checker takes a page’s raw HTTP response headers — pasted from curl -I https://your-site.com or from DevTools → Network → the document request → Response Headers — and analyzes them against widely-cited best practices in four GROUPS. SECURITY is checked against the OWASP Secure Headers Project set: Strict-Transport-Security (HSTS) forcing HTTPS, Content-Security-Policy restricting script/style/frame sources (the main XSS defence), X-Frame-Options or the modern CSP frame-ancestors against clickjacking, X-Content-Type-Options: nosniff against MIME sniffing, Referrer-Policy against referrer leakage, Permissions-Policy locking down unused browser features, and the Cross-Origin-Opener / Embedder / Resource-Policy isolation trio — with penalties for advertising the deprecated X-XSS-Protection or leaking the stack via Server (with a version) and X-Powered-By, which OWASP recommends removing. SEO covers the headers a crawler reads, flagging a header-level X-Robots-Tag noindex / nofollow PROMINENTLY (it removes the URL from search) alongside Link rel=canonical, Content-Type + charset, Content-Language and Vary. CACHING / performance covers Cache-Control, the ETag / Last-Modified validators and Content-Encoding compression (gzip / brotli / zstd). A fourth Server group surfaces fingerprinting headers and any redirect. Each header becomes a card — present with its value and a strength verdict, or missing with why it matters and the exact line to add.
Four groups: Security (OWASP), SEO, Caching, Server — each header present-with-strength or missing-with-fix
Penalizes deprecated X-XSS-Protection and leaky Server / X-Powered-By headers OWASP says to remove
PROMINENTLY flags a header-level X-Robots-Tag noindex (removes the URL from search results)
All analysis runs in the browser via plain string parsing — no server call, no CDN, no upload
⚙️Methodology
How It Parses the Headers and Computes the Score
A small, pure, well-typed engine, httpHeaderEngine.ts, does the work with plain string parsing and no dependency. parseHeaders(raw) builds a case-insensitive multi-map: it recognises and captures an optional HTTP status line (HTTP/2 200, HTTP/1.1 301 …), splits each remaining line on the first colon into a lower-cased name and a value, PRESERVES duplicate headers as an ordered list, folds obsolete continuation lines (leading whitespace) into the previous line, strips curl’s < / > / * markers, and rejects non-token names so pasted prose is ignored — so it robustly handles curl -I output and DevTools copies. analyzeHeaders(map) then runs each group’s rules, producing for every header a check with a severity (good / warn / missing / bad), the value, a message and a concrete recommendation (with a copyable “add this” line for missing headers). The 0–100 SECURITY SCORE is a weighted roll-up: the largest weights go to HSTS and CSP, then X-Frame-Options / frame-ancestors and nosniff, then Referrer-Policy, Permissions-Policy and the Cross-Origin headers, each scaled by the strength of its value (e.g. HSTS scores higher with a one-year+ max-age and includeSubDomains; CSP scores lower with unsafe-inline / unsafe-eval), minus bounded penalties for deprecated / leaky headers. The normalized score maps to an A–F grade with a plain-language verdict. Checks are grouped and ordered bad → missing → warn → good, and a copyable plain-text report is generated locally.
No new dependency, no network — pure client-side string parsing
⚠️Limitations
Paste the Headers (CORS), and It’s Guidance, Not a Pentest
The tool is explicit about two honest limits. First, you must PASTE the headers: a browser cannot read another site’s HTTP response headers directly — cross-origin header access is restricted by the Same-Origin Policy / CORS, so JavaScript can only see a few “safelisted” response headers from a different origin and essentially none of the security headers — and we deliberately use NO server proxy (which is what keeps everything private and lets you check staging or internal sites). Many online scanners fetch your URL server-side, which exposes the URL and configuration to their servers; we don’t. So the reliable path is to get the headers yourself with curl -I https://your-site.com (or curl -sD - -o /dev/null https://your-site.com) or from DevTools → Network → Response Headers, and paste them in; the optional “try to fetch” box only demonstrates the CORS limit. Second, it is GUIDANCE, not a full penetration test: it checks common security, SEO and caching headers against best-practice references (OWASP Secure Headers, MDN, Google Search Central), but it only sees the headers you paste — not your TLS / certificate configuration, cookie flags, application logic, input validation or runtime behaviour. A high score means good header hygiene, not a secure application. Always verify against your actual server / CDN config and cross-check with a dedicated scanner such as securityheaders.com or Mozilla Observatory.
Paste the headers — a browser can’t read cross-origin response headers (CORS); no server proxy keeps it private
Get them via curl -I / curl -sD - or DevTools → Network → Response Headers
It only sees the headers you paste — not TLS, cookie flags, app logic or runtime behaviour
Best-practice guidance, NOT a penetration test — a high score is header hygiene, not app security
Verify with your server config + securityheaders.com or Mozilla Observatory
🔒Privacy & Security
Why Checking Headers In-Browser Is a Privacy Win
Online header scanners fetch your URL from their servers, which reveals which site (often a not-yet-public one) you are testing and hands its configuration to a third party. The HTTP Header Checker instead runs entirely on the user’s device: the headers you paste are parsed and analyzed with plain JavaScript in the browser, nothing is fetched, uploaded, logged or stored, and no site is ever contacted (there is deliberately no server proxy). That makes it safe to check the headers of STAGING, INTERNAL or PRE-LAUNCH sites — you can copy the output of curl -I against a private host and analyze it without any of it leaving your machine. The tool works offline once cached as a PWA, and closing the tab discards everything entered. It adds no new dependency: all the parsing and scoring live in the compact, well-typed httpHeaderEngine.ts. Because the copyable text report is also built locally, the whole workflow — paste, analyze, read the grouped cards, copy the report — never touches the network.
Headers are parsed locally and never uploaded — no server, no CDN, no proxy, no site is contacted
Works offline once cached; closing the tab discards your data
No new dependency — all parsing and scoring live in httpHeaderEngine.ts
Dark mode and mobile support with a sticky Analyze / Copy bar
HTTP header checking: in-browser (AnyTool) vs online scanners
Capability
AnyTool
Typical online scanners
Processing
Runs entirely in your browser
Fetch your URL from their server
Your data
Headers pasted, never uploaded
URL + config sent server-side
Staging / internal sites
Safe — paste curl -I output privately
Server must be able to reach the URL
Input
Paste headers (curl -I / DevTools)
A URL the tool fetches
Coverage
Security (OWASP) + SEO + caching, in groups
Often security-only
X-Robots-Tag noindex
Flagged prominently (SEO impact)
Rarely
Score
0–100 weighted by header strength + A–F grade
Varies
Scope honesty
Guidance, not a pentest — stated clearly
Sometimes overstated
Cost / signup
Free, no signup
Often gated or ad-heavy
AnyTool analyzes headers locally from what you paste and uploads nothing, which is safe for staging or internal sites. Because a browser cannot read another site’s response headers cross-origin (CORS) and there is no server proxy, you paste the headers from curl -I or DevTools. It checks common security / SEO / caching headers against best practice — it is guidance, not a full penetration test; verify with your server config and securityheaders.com or Mozilla Observatory. Comparison as of July 2026.