HTTP 103 Early Hints: Faster Page Loads Explained
HTTP 103 Early Hints lets a server tell the browser which assets to fetch before the final response is ready. How it works, when it helps, and its limits.
HTTP 103 Early Hints is an informational status code that lets a server send a preliminary response — containing only headers — before the real response is ready. Those headers are usually Link headers that tell the browser to preload a stylesheet or open a connection to another origin. The browser starts that work immediately, so by the time the HTML arrives, critical resources are already downloading or done. It reclaims time the browser would otherwise spend waiting on the server.
The problem it solves: server think time
When a browser requests a page, the server often needs time before it can send the first byte of HTML. It might query a database, call a few internal APIs, or render a template. During that window the connection sits idle, and the browser has nothing to do because it does not yet know what the page needs.
That idle stretch shows up directly in time to first byte. Yet for most pages, the server knows long before the HTML is finished that the page will need the same main stylesheet, the same font files, and a connection to the same image CDN it always uses. Those facts rarely depend on the database query.
Early Hints lets the server say so up front.
How the exchange works
A 1xx status code is informational: it does not end the request. A server can send one or more 1xx responses before the final response. The 103 code was defined specifically to carry hints.
HTTP/1.1 103 Early Hints
Link: </styles/main.css>; rel=preload; as=style
Link: </fonts/inter.woff2>; rel=preload; as=font; crossorigin
Link: <https://images.example.com>; rel=preconnect
HTTP/1.1 200 OK
Content-Type: text/html
Link: </styles/main.css>; rel=preload; as=style
...
<!doctype html>
...
The browser receives the 103, reads the Link headers, and kicks off the preload and preconnect immediately. When the 200 arrives with the HTML, the stylesheet may already be in the cache. The page then renders sooner because the critical rendering path is no longer blocked on a network round trip for CSS.
The hints use the same vocabulary you would put in HTML. If you already understand preload, prefetch, and preconnect, you understand what Early Hints can carry. The difference is timing: a <link rel="preload"> in the HTML can only be discovered once the HTML starts arriving, while a 103 can be sent the instant the request lands.
Early Hints vs other ways to start fetching early
<link> hints in HTML | Link header on the 200 | 103 Early Hints | |
|---|---|---|---|
| When the browser learns about it | After HTML starts parsing | When response headers arrive | Before the final response exists |
| Covers server think time | No | No | Yes |
| Requires server or CDN support | No | Minimal | Yes |
| Can be withdrawn later | Yes (change the HTML) | Yes | No |
| Typical use | Page-specific assets | Same as HTML hints | Stable, site-wide critical assets |
HTTP/2 server push once tried to solve the same problem by sending the resources themselves without being asked. It proved hard to use well — servers frequently pushed files the browser already had cached — and browsers have largely removed support. Early Hints is the replacement: the server suggests, and the browser decides, using its own cache to skip anything it already has.
Where Early Hints helps most
The benefit is roughly proportional to how long the server takes to produce the final response.
- Dynamic, server-rendered pages with noticeable backend latency see the largest gains. A few hundred milliseconds of think time can be fully overlapped with fetching CSS and fonts.
- Pages behind a CDN are a good fit. Several CDNs can remember the
Linkheaders from earlier responses for a URL and emit a 103 automatically from the edge while the request travels to the origin, so the origin does not need to change. - Cross-origin assets benefit from
preconnecthints, which let the browser finish DNS, TCP, and TLS setup with a third-party host before it is needed.
Pages that are already served from cache in a few milliseconds gain little; there is no idle gap to fill.
Limits and caveats
Browser support is not universal. Support has expanded over time but varies by browser and sometimes by protocol; some browsers only act on Early Hints over HTTP/2 or HTTP/3. Clients that do not understand a 103 simply discard it, so sending one is safe even when it is ignored.
Only certain hints are honored. Browsers generally act on preload and preconnect in Early Hints. Do not expect other Link relations, Set-Cookie, or arbitrary headers in a 103 to take effect.
Hints apply to navigations. The mechanism targets top-level page loads, not every subresource request.
You cannot take a hint back. Once the 103 is sent, the browser may already be fetching. If the final response turns out to be a redirect, an error, or a page that uses a different stylesheet, those fetches are wasted bandwidth. Hint only resources that every response for that URL will need.
Do not overdo it. Preloading everything competes with the HTML itself for bandwidth. Keep the list short: the main stylesheet, one or two critical fonts, and preconnects to origins the page always uses. The rest of the status code family is about outcomes; 103 is only about getting a head start.
How to tell if it is working
Open the network panel in your browser’s developer tools and reload. Resources fetched because of a 103 typically start before the document request has finished, and some tools label the initiator as Early Hints. Compare the start time of your stylesheet against the arrival of the HTML: with Early Hints active, the stylesheet should begin first.
Then measure what users feel. Early Hints usually shows up as improvements in First Contentful Paint and Largest Contentful Paint — two of the metrics in our Core Web Vitals guide — rather than in TTFB, which may not change at all. Field data from real users is more trustworthy than a single lab run, because the gain depends on each visitor’s network and on how long your server takes.
The takeaway
HTTP 103 Early Hints fills the dead time while a server builds a response by sending Link headers first, so the browser can preload critical CSS and fonts and warm up connections in parallel. It helps most on dynamic pages with real backend latency, costs almost nothing when unsupported, and is easiest to adopt at the CDN layer. Keep the hint list short and stable, because once a hint is sent it cannot be withdrawn.
Keep reading
The Lycoris Team · · 5 min read Head-of-Line Blocking Explained: HTTP/1.1, HTTP/2, QUIC
Head-of-line blocking is when one stalled item holds up everything queued behind it. How it affects HTTP/1.1, HTTP/2 over TCP, and how QUIC fixes it.
Takina · · 4 min read The Server-Timing Header Explained
The Server-Timing HTTP header exposes backend performance metrics — database time, cache hits — directly in the browser's DevTools network panel.
Takina · · 4 min read What Is WebTransport? A Guide to the API
WebTransport is a browser API for low-latency, bidirectional client-server messaging over HTTP/3. How it works and when to reach for it.