On a site proxied by Cloudflare, which files does the edge cache by default, and why do HTML pages show cf-cache-status DYNAMIC?
answer
- extension, not content type
- a fixed list of static types
- HTML and JSON left out
- decided before any cache lookup
basics
~20 sCloudflare caches by file extension: images, CSS, JavaScript, fonts, media, documents and archives, plus robots.txt. HTML, JSON and extensionless paths are not on the list, so those requests go to the origin without a cache lookup and show DYNAMIC.
solid answer
~40 sBy default Cloudflare decides cache eligibility from the URL's **file extension**, not the response's `Content-Type`. A fixed list (`css`, `js`, `jpg`, `png`, `webp`, `svg`, `woff2`, `pdf`, `mp4`, `zip` and dozens more, plus `robots.txt`) is eligible; HTML, JSON and extensionless paths such as `/articles/123` are not. For an ineligible request the edge skips the cache entirely and returns `cf-cache-status: DYNAMIC`. Origin headers do not change that: `Cache-Control: public, max-age=600` on an article page still yields `DYNAMIC`, because origin directives only govern responses that are already eligible. Caching HTML takes a Cache Rule that makes the path eligible. Development Mode or a bypass rule can also turn normally cached files `DYNAMIC`.
code
console · 5 lines$ curl -sI https://news.example.com/articles/2026/budget-vote | grep -i cf-cache-status
cf-cache-status: DYNAMIC
$ curl -sI https://news.example.com/static/site.css | grep -i -E '^(cf-cache-status|age):'
cf-cache-status: HIT
age: 5120go deeper
Recall that the default is extension-based, that HTML and JSON are not on the list, and that DYNAMIC means the request never touched the cache.
Explain that eligibility is decided at request time from the path, so origin Cache-Control cannot rescue an HTML page, and name Development Mode and bypass rules as other DYNAMIC causes.
Show the diagnostic habit: read cf-cache-status per URL with curl, separate request-time DYNAMIC from response-time BYPASS, and confirm with Cloudflare Trace before touching origin code.
Frame the default as a safety posture: nothing per-user is stored unless someone opts a path in, so any HTML caching must be an explicit, reviewed decision.
## How Cloudflare decides whether a request may use the cache When a hostname is **proxied** through Cloudflare (the orange cloud on its DNS record), every request passes through a Cloudflare data center before it reaches the origin. Before the edge looks in its cache, it makes a **request-time eligibility decision**: may this request be answered from cache at all? Without any Cache Rule, that decision rests on one thing: the **file extension at the end of the URL path**. Cloudflare's documentation states it plainly: Cloudflare caches based on file extension and not by MIME type, and the CDN does not cache HTML or JSON by default. The response's `Content-Type` plays no part in this first decision, because the decision is made before any response exists. ## The default list of cached extensions The list covers static, mostly immutable file types. Grouped by kind: | Kind | Examples on the default list | |---|---| | Styles, scripts and code | `css`, `js`, `ejs`, `class`, `jar` | | Images | `jpg`, `jpeg`, `png`, `gif`, `webp`, `avif`, `svg`, `svgz`, `ico`, `bmp`, `tif`, `tiff` | | Fonts | `woff`, `woff2`, `ttf`, `otf`, `eot` | | Audio and video | `mp3`, `mp4`, `webm`, `ogg`, `flac`, `mkv`, `avi`, `mid`, `midi` | | Documents | `pdf`, `doc`, `docx`, `xls`, `xlsx`, `ppt`, `pptx`, `csv`, `eps`, `ps` | | Archives and binaries | `zip`, `gz`, `bz2`, `7z`, `rar`, `tar`, `zst`, `iso`, `dmg`, `exe`, `apk`, `bin` | On top of the list, Cloudflare caches a site's `robots.txt` by default. Missing from the list are `html`, `htm`, `json`, `xml` and every **extensionless path**, such as `/articles/2026/budget-vote` or `/api/scores`. On a typical news site that means the stylesheet, scripts, photos and fonts are eligible, while every article page and every JSON feed is not. ## What `DYNAMIC` means Cloudflare reports its cache decision in the `cf-cache-status` response header. `DYNAMIC` means Cloudflare decided **at request time** that the request was not eligible, so it forwarded the request to the origin **without a cache lookup** and did not store the response. It is not a failed lookup (that is `MISS`), and it is not the origin refusing storage (that is `BYPASS`, a decision made later, at response time). So an article page showing `DYNAMIC` is the default working as designed. Every visitor's request for that page travels to the origin, which is why HTML time to first byte often barely moves after a site goes behind the proxy while images speed up dramatically. ## Why origin headers do not make HTML cacheable A common first fix is to send `Cache-Control: public, max-age=600` on article pages. Under the default configuration it changes nothing at the edge: the page still shows `DYNAMIC`. Origin cache directives govern **how long and whether** Cloudflare stores a response that is already eligible; they never make an ineligible request eligible. The header still travels to browsers, which may cache the page themselves. To have the edge store HTML or JSON, a team adds a **Cache Rule** that marks the matching paths as eligible for cache, and then must take care that per-user pages are excluded. Writing that rule is its own subject, covered with Cache Rules. ## Other reasons for `DYNAMIC` `DYNAMIC` can also appear on files that are normally cached: - **Development Mode** is on. It suspends the edge cache (and Polish) for three hours, and every response returns `DYNAMIC`. It does not purge anything; cached files are used again when it ends. - A Cache Rule with the **Bypass cache** setting matches the URL, or a legacy `Cache Level: Bypass` setting in a Configuration Rule or Page Rule does. - The request method is not `GET` or `HEAD`. Cloudflare turns a cacheable `HEAD` into a `GET` toward the origin, caches the full response and returns only the headers. ## Checking it yourself 1. Request the page and an asset with `curl -sI` and read `cf-cache-status` on each. 2. Repeat the asset request: the first request in a data center is `MISS`, later ones `HIT` with an `Age` header that grows. 3. If an asset you expected to be cached shows `DYNAMIC`, check Development Mode on the zone's Caching > Configuration page, then use **Cloudflare Trace** to see which rules match the URL. Reading `DYNAMIC` correctly saves hours: it points at the URL and the zone's rules, never at the origin's response headers.
- An endpoint at /api/scores.json on a Cloudflare zone sends Cache-Control: public, max-age=30 and still shows DYNAMIC. Why?`json` is not on Cloudflare's default extension list, so the request is ineligible before any response arrives, and origin directives only apply to eligible requests. The edge needs a Cache Rule that makes the path eligible; the origin's `max-age=30` then sets the lifetime. Before adding one, confirm the feed is identical for every visitor, since the edge would serve one stored copy to all of them.
- A Cloudflare zone's stylesheet that normally shows HIT now shows DYNAMIC on every request. What do you check?First, whether **Development Mode** is on: it suspends the edge cache for three hours and returns `DYNAMIC` for everything, without purging. Then whether a Cache Rule with **Bypass cache**, or a legacy `Cache Level: Bypass` Configuration Rule or Page Rule, now matches the path; Cloudflare Trace shows which rules apply to the URL. Finally, confirm the request method is `GET`.
- Does an image served from /render?id=42 with Content-Type image/png get cached by default on Cloudflare?No. The eligibility decision looks at the URL's extension, and `/render` has none, so the request is `DYNAMIC` whatever `Content-Type` the origin later returns. Either serve the image under a path that ends in `.png`, or add a Cache Rule for that path.
A left-luggage office that only accepts the bag sizes printed on its sign: a newspaper is handed straight from the press to the reader every time, however loudly its wrapper says 'store me'.
- Cloudflare caches every response by default unless the origin says not to.
- Cloudflare decides what to cache from the response's Content-Type header.
- Sending Cache-Control: public, max-age on HTML makes Cloudflare cache it by default.
- DYNAMIC means Cloudflare looked in its cache and did not find the page.
- Turning on Development Mode purges the zone's cache.