ForHosting KIT · Web Scraping & Monitoring

ETag weak or strong check

Paste an ETag and see at once whether it is weak or strong: W/"abc123" is weak, with abc123 as its inner tag, while "v1-hash" is strong. Missing quotes or a lowercase w/ are flagged instead of guessed. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Etag: W/"abc123"

You get

Strength: weak
Opaque tag: abc123
Quoted tag: "abc123"
Prefix: W/

A strong validator asserts an exact byte-for-byte match; a weak validator, marked with the case-sensitive W/ prefix before the quoted opaque-tag, only asserts semantic equivalence. Mis-parsing that prefix or accepting an unquoted token leads to wrong If-Match and If-None-Match decisions, stale cache hits, and lost conditional updates. This capability accepts a single ETag header value (or a full ETag: line), checks that the opaque-tag is properly enclosed in double quotes per RFC 9110, classifies the validator as weak or strong, and returns the normalized tag parts.

What weak and strong ETags mean under RFC 9110

An entity-tag is an opaque quoted string that a server associates with a specific representation of a resource. When the server intends a strong validator, it emits only the quoted tag, for example "v3-a1b2c3". When it intends a weak validator, it prefixes that quoted tag with the case-sensitive token W/ so the full value looks like W/"v3-a1b2c3".

Strong validators may be used for both cache revalidation and for safe partial-content or range decisions that require an exact match. Weak validators only guarantee that the representations are equivalent for caching purposes; they must not be treated as proof that every byte is identical. Conditional request headers such as If-Match, If-None-Match, and If-Range compare the client-supplied tags against the current server tag using these rules.

If a client or middleware strips the W/ prefix by accident, a weak tag is treated as strong and may incorrectly allow a range request or a conditional write. If quotes are dropped, intermediaries and parsers disagree on where the token ends. This checker exists so you can validate a stored or logged ETag string before you compare it, document it, or feed it into another system that expects strict RFC form.

What you can paste and what gets rejected

You may paste either the bare entity-tag or a full header line such as ETag: W/"abc". Leading and trailing whitespace is trimmed; an optional ETag: name prefix is stripped case-insensitively. The remaining value must be either "opaque" for a strong validator or W/"opaque" for a weak one.

The W must be uppercase; a lowercase w/ is rejected because RFC 9110 defines the weak marker as case-sensitive. The opaque-tag must start and end with double quotes, must not contain an internal unescaped double quote, and may only use etagc characters: printable ASCII except quote, plus obs-text. Example: "v1-hash" yields strong true and strength strong.

What you can do with it

CDN and gateway header audits

Paste production ETag samples and confirm which responses use weak versus strong validators before tuning cache and revalidation rules.

Support and HAR triage

Classify ETags from HAR files or tickets in the free browser tool so conditional request bugs are diagnosed without custom scripts.

FAQ

How do I tell if an ETag is weak or strong?

Send the ETag value (for example W/"abc" or "abc"). If it starts with the case-sensitive W/ prefix before the quoted tag, strength is weak; otherwise a properly quoted tag is strong.

What happens if the ETag is not quoted?

RFC 9110 requires the opaque-tag to be enclosed in double quotes; unquoted tokens are rejected rather than guessed.

Is the W/ prefix case-sensitive?

Yes. Only uppercase W/ is the weak marker. Values like w/"tag" are rejected so you do not silently treat a non-conforming prefix as strong or weak.

Can I paste a full ETag: header line?

Yes. A leading ETag: name is stripped case-insensitively; the remaining entity-tag is then classified.

When does it matter whether an ETag is weak or strong?

When a cache or a client compares tags to decide whether something changed. A strong tag proves an exact byte-for-byte match and can back partial downloads or safe updates; a weak one only says two versions are equivalent for caching.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/web/etag-weak-strong-check

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/web/etag-weak-strong-check \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"etag":"W/\"abc123\""}'

const res = await fetch("https://api.kit.forhosting.com/web/etag-weak-strong-check", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "etag": "W/\"abc123\""
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/web/etag-weak-strong-check",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "etag": "W/\"abc123\""
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/etag-weak-strong-check", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"etag":"W/\\"abc123\\""}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"etag":"W/\"abc123\""}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/etag-weak-strong-check", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "etag": "W/\"abc123\""
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "web.etag_weak_strong_check",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`timeout_sec`	30
`max_crawl_pages`	25

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

HTTP entity tags (ETags) tell caches and clients whether two representations of a resource are the same. Invalid quotes, empty values, and non-RFC weak prefixes fail with invalid_input instead of a silent false classification. The same pure parse logic powers the free browser tool and the prepaid API path.

Input contract, response fields, and rejection rules

POST a JSON body with one required string field named etag (aliases value, header, tag, and entity_tag are accepted). On success the response includes etag (normalized W/ plus quoted form or quoted form alone), weak and strong booleans, strength as the string weak or strong, opaque_tag (inner content without quotes), quoted_tag, prefix (either empty or W/), valid true, and a short note describing the validator class. Missing input, empty strings after stripping the header name, unquoted tags such as abc123, mismatched quotes, illegal characters, and bad weak prefixes all raise invalid_input and are not billed. Example: W/"abc123" yields weak true, strength weak, opaque_tag abc123.

Where an ETag strength checker earns its place

Failed validation does not consume balance. API gateways and CDN configuration reviews often collect sample response headers and need a quick, deterministic answer to whether each ETag is weak or strong before writing cache policies. Automated contract tests for REST services can assert that versioned JSON documents emit strong tags while rendered HTML pages deliberately use weak tags, failing the build when quotes or the W/ prefix drift. Content sites targeting queries such as etag weak strong validator gain a live tool whose free client path matches the paid API path on the same pure module. Keep the opaque-tag opaque in your product docs—this endpoint never hashes your body for you; it only classifies the tag format you already have—and pin the goldens when you embed the checker in CI.

Integration use cases

API contract and CI checks

Assert in tests that a service emits properly quoted strong or weak ETags and fails the pipeline on missing quotes or a bad W/ prefix.

Technical questions

What does the ETag weak or strong check cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free