skip to content

In Cloudflare's cf-cache-status header, what do HIT, MISS, EXPIRED, UPDATING, BYPASS and DYNAMIC mean, and how do BYPASS and DYNAMIC differ?

level: middleimportance: must knowfreq 65%

answer

  1. one data center, one request
  2. request time versus response time
  3. uncacheable responses get one label
  4. stale served while asking the origin

basics

~20 s

HIT is served from cache, MISS is cacheable but fetched, EXPIRED is a stale copy refetched, UPDATING is stale served during background revalidation. DYNAMIC means ineligible at request time; BYPASS means eligible, but the origin's response could not be stored.

solid answer

~40 s

`cf-cache-status` reports what one data center's cache did for one request. `HIT` came from cache, with an `Age` header; `MISS` was cacheable but not present, so the origin was asked; `EXPIRED` was found stale and fetched again; `REVALIDATED` was confirmed unchanged by a conditional request; `UPDATING` was a stale copy served while `stale-while-revalidate` refreshes it in the background; `STALE` was served because the origin was unreachable. The key distinction is timing: `DYNAMIC` is decided **before** any lookup (no cached extension, a Bypass cache rule, Development Mode), so look at the URL and rules; `BYPASS` is decided **after** the origin answers (`no-store`, `private`, `Set-Cookie`, `Vary: *`, size limit), so look at the origin's response. As of 2026, every refusal to cache reports `BYPASS`, never `MISS`.

code

http · 7 lines
http
HTTP/2 200
content-type: text/css
cache-control: public, max-age=86400
cf-cache-status: HIT
age: 3127
server: cloudflare
cf-ray: 8d2f6a1c3b7e9f10-LHR

go deeper

for a junior

Know HIT, MISS and DYNAMIC on sight, and that the first request in each data center is a MISS.

for a middle

Explain BYPASS as a response-time refusal and DYNAMIC as a request-time ineligibility, list the usual cause of each, and describe UPDATING with stale-while-revalidate.

for a senior

Use the label to route an investigation: rules and URL for DYNAMIC, origin headers for BYPASS, cf-ray location and cache-key variance for repeated MISS, and know the 2026 label changes when reading old dashboards.

for a principal

Treat cache-status mix as an operating metric: a rise in BYPASS after a release usually means an origin change, and hit ratios before and after May 2026 are not directly comparable.

## Where `cf-cache-status` comes from Every response a proxied Cloudflare hostname serves can carry a `cf-cache-status` header. It records what the edge cache in **that one data center** decided for **that one request**. Reading it correctly is the fastest way to tell a working cache from a broken one, because each value points at a different place to look: the URL and rules, the origin's response headers, or simply the first request at a new location. The data center is named by the last three characters of the `cf-ray` header (for example `-LHR`). Two requests that land in different data centers each start with their own empty cache, so a `MISS` followed by another `MISS` is only suspicious when both came from the same location. ## The values and what each one means | Value | What happened | Where to look | |---|---|---| | `HIT` | Served from the edge cache | Nothing; `Age` shows seconds since storage or revalidation | | `MISS` | Eligible and cacheable, but not in this data center's cache yet; fetched from the origin | Expected on the first request per location | | `EXPIRED` | Found in cache but stale; fetched again from the origin | The origin's freshness lifetime | | `REVALIDATED` | Stale copy confirmed unchanged by a conditional request, then served from cache | Normal for `no-cache` or short lifetimes | | `UPDATING` | Stale copy served while the origin is asked in the background | `stale-while-revalidate` is at work | | `STALE` | Expired copy served because the origin could not be reached | The origin's health | | `BYPASS` | Eligible at request time, but the **origin response** was not cacheable | The origin's response headers and size | | `DYNAMIC` | **Not eligible** at request time, so no cache lookup at all | The URL's extension, Cache Rules, Development Mode | A further value, `NONE/UNKNOWN`, appears when Cloudflare answered before the cache was involved: a Worker built the response itself, a WAF custom rule blocked the request, or a redirect rule or Always Use HTTPS sent a redirect. ## BYPASS versus DYNAMIC: when the decision was made The two "not served from cache" labels differ in **timing**, and the timing tells you where the cause lives. - **`DYNAMIC` is a request-time decision.** Before any response exists, Cloudflare judged the request ineligible: the path has no extension on the default list (HTML, JSON, `/articles/42`), a Cache Rule says **Bypass cache**, Development Mode is on, or the method is not `GET` or `HEAD`. The origin's headers are irrelevant to this label. - **`BYPASS` is a response-time decision.** The request was eligible, by the default list or by a Cache Rule, but the origin's answer could not be stored. Typical causes on a Free, Pro or Business zone, where Origin Cache Control is always on: - `Cache-Control: no-store` or bare `private`; - a `Set-Cookie` header on the response; - `Vary: *`; - a body larger than the plan's maximum cacheable size (512 MB on Free, Pro and Business; 5 GB by default on Enterprise); - `no-store` or bare `private` in `CDN-Cache-Control` or `Cloudflare-CDN-Cache-Control`; - an `Authorization` request header without `public`, `s-maxage` or `must-revalidate` in the response. A useful corollary: if a Cache Rule makes HTML eligible and the origin then returns `no-store`, the page shows `BYPASS`, not `DYNAMIC`. ## What changed in 2026 Two behaviours are recent, and older write-ups describe them differently: 1. **`BYPASS` is now consistent.** Since a change dated 2026-05-26, every response Cloudflare refuses to cache reports `BYPASS`, whatever the reason. Before it, some refusals, such as files over the cacheable size limit, reported `MISS` on every request, which looked exactly like a broken cache. `MISS` now means only "cacheable, not here yet", and hit ratios in analytics rise accordingly, because uncacheable traffic no longer counts as misses. 2. **`stale-while-revalidate` is asynchronous.** Since 2026-02-26, when an origin sends `stale-while-revalidate`, the first request after expiry gets the stale copy at once with `UPDATING` while Cloudflare revalidates in the background; once the origin answers, requests return `HIT`. Free, Pro and Business zones had it first, and Enterprise zones followed in a staged rollout. `REVALIDATED` and `EXPIRED` remain for the synchronous path: no `stale-while-revalidate`, or directives such as `must-revalidate`, `proxy-revalidate`, `s-maxage` or `no-cache` that forbid serving stale. ## A reading routine 1. `DYNAMIC` on something you expected cached: look at the URL and the zone's rules, not the origin. 2. `BYPASS`: fetch the origin directly and read its `Cache-Control`, `Set-Cookie`, `Vary` and size. 3. `MISS` twice from the same `cf-ray` location: the cache key differs per request (often a changing query string) or the object was evicted; both are covered with cache keys and Tiered Cache. 4. `HIT` with a growing `Age`: the cache is doing its job.

  • On Cloudflare, why might a file show MISS on two consecutive requests even though it is cacheable?
    Compare the last three characters of `cf-ray`: if they differ, the requests reached two data centers, each with its own first `MISS`. If they match, the cache key is probably different each time, for example a changing query string such as a tracking parameter, or the object was evicted for low traffic. Cache key settings and Tiered Cache address those.
  • When does a Cloudflare response show NONE/UNKNOWN instead of a cache status?
    When the edge answered before the cache was involved: a Worker generated the response without a subrequest, a WAF custom rule blocked the request, or a redirect rule or Always Use HTTPS issued a redirect. A Worker's own `fetch()` subrequests are logged with their real cache status, while the main request is logged as `none/unknown`.
  • A Cloudflare zone's cache hit ratio rose in mid-2026 with no configuration change, while MISS fell and BYPASS grew. What happened?
    The labels changed, not the traffic. Since the 2026-05-26 change, every response Cloudflare refuses to cache reports `BYPASS`; before it, some refusals, such as files over the cacheable size limit, were counted as `MISS`. Those requests left the hit-ratio calculation, so the ratio rose while origin traffic stayed the same. Compare periods across that date with care.

  • BYPASS and DYNAMIC are two names for the same thing.
  • A MISS on every request means the file is too big to cache.
  • DYNAMIC means the origin sent Cache-Control: no-store.
  • HIT means every data center now holds the file.
  • The first request after expiry always waits for the origin, even with stale-while-revalidate.

Assumes Cloudflare's cache as of 2026-10-10: since 2026-05-26 every uncacheable response reports BYPASS (over-size files used to show MISS), and since 2026-02-26 stale-while-revalidate serves UPDATING asynchronously.