Articles

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.

Takina Takina · · 5 min read
Performance metrics displayed on a screen

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 HTMLLink header on the 200103 Early Hints
When the browser learns about itAfter HTML starts parsingWhen response headers arriveBefore the final response exists
Covers server think timeNoNoYes
Requires server or CDN supportNoMinimalYes
Can be withdrawn laterYes (change the HTML)YesNo
Typical usePage-specific assetsSame as HTML hintsStable, 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 Link headers 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 preconnect hints, 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.

The Lycoris Team 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.

#Networking #Web Development #Performance
Takina 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.

#Web Development #Performance #Networking
Takina 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.

#Web Development #Networking #Performance