Early Hints and How to Accelerate Your Website Loading Time

Short answer: Early Hints is an HTTP status code, 103, that a server sends before the real page. It carries Link headers that tell the browser which files to download, or which servers to connect to, while the page is still being built.

It helps under one condition. The server has to need real time before it can send the final 200 response. And the page has to depend on critical CSS, fonts or third-party origins worth fetching early. A page that comes out of a cache in a few milliseconds leaves no wait to fill, so an ordinary preload does the same job.

Last reviewed: October 2026. Browser support and vendor documentation were checked on 21 October 2026, and every Apache, Nginx and WordPress command below was run that day in Docker.

• Chrome and Edge have acted on preload and preconnect hints since version 103 (June 2022). Firefox caught up in 2023 and 2024. Safari acts on preconnect only.
• In our Apache 2.4.69 test, the 103 reached Chrome about 1 second before the page, and the stylesheet was already downloaded when the HTML arrived.
• Nginx passes a 103 on only from version 1.29.0, and Ubuntu 26.04 LTS still ships 1.28.3.
• We checked the homepages of 31 hosting companies. Two sent a 103.

How a 103 Response Works, Step by Step

Without Early Hints, every page load has a dead spot. The browser asks for the page, then waits while the server runs PHP, queries the database and assembles the HTML. Only when the HTML arrives can the browser read it, find the stylesheet and ask for that too.

Early Hints fills the dead spot. The server, or a CDN in front of it, answers at once with a 103 that names a few files. The browser starts on those while the real response is still being built. When the 200 arrives, the stylesheet is already in the browser’s cache.

One navigation in our Docker test: the hinted stylesheet was downloaded while Apache was still building the page. Source: howtohosting.guide test, 21 October 2026, using Chrome’s navigation timing and Apache’s access log.

In our own test, described below, the 103 reached Chrome 12.6 ms after the navigation started. The final headers came at 1,020.1 ms. Chrome fetched the stylesheet in that gap, so it never waited for it after the HTML landed.

The format comes from RFC 8297, an experimental IETF specification published in December 2017. It’s clear that hints are only hints: “they do not replace the header fields on the final response”. A server may send several 103 responses, but browsers process only the first, according to MDN’s reference page.

Browsers act on two kinds of hint. rel=preload downloads a file, such as a stylesheet or a font. rel=preconnect opens a connection to another server early, which covers the DNS lookup and the TLS handshake (the encryption setup). Chrome ignores prefetch in a 103.

Early Hints replaced HTTP/2 server push, which let a server send files nobody had asked for yet. Push often resent files the browser already had, and Chrome’s data showed it was a net loss for the web. Chrome turned push off by default in Chrome 106, released on 27 September 2022. Early Hints costs one extra round trip, but the browser decides what it actually needs.

Browser Support in 2026

Every major browser now reads a 103, but not every browser acts on every hint. The versions below come from MDN’s browser compatibility data and from Chrome’s Early Hints guide.

Safari’s gap changes what you should hint. A Safari visitor ignores every preload, and a preconnect to your own server does nothing because that connection is already open. For Safari users, Early Hints only helps when the 103 preconnects to third-party origins, such as a font or image CDN.

Chrome documents more limits. It acts on a 103 only for the main page of a tab, not for images, scripts or iframes. If the final response redirects to another origin, Chrome throws away what it fetched. Preloaded files go into the HTTP cache, so a file that can’t be cached gets downloaded twice. Responsive image preloads (with imagesrcset) gain little from a 103, because Chrome’s guide says they wait for the page at best.

The old advice to test in “Chrome 94 or higher” dates from Chrome’s origin trial, which ran from Chrome 94 to 98. Chrome 103 switched Early Hints on for everyone, and no flag is needed.

Our Test: Apache Sends a 103 Before a Slow Page

We built the smallest setup that shows the effect. It ran on 21 October 2026 in Docker, with the official httpd:2.4 image (Apache 2.4.69, OpenSSL 3.5.7) and a self-signed certificate. A tiny CGI script waits 1 second before it prints the page, standing in for PHP and database work.

In the image’s httpd.conf, we uncommented the LoadModule lines for mod_ssl, mod_http2, mod_socache_shmcb and mod_cgid. Then we included this file:

Listen 443
Protocols h2 http/1.1
H2EarlyHints on

<VirtualHost *:443>
    ServerName localhost
    SSLEngine on
    SSLCertificateFile conf/server.crt
    SSLCertificateKeyFile conf/server.key
    DocumentRoot htdocs

    # Test only: log when each request started and ended, in milliseconds
    LogFormat "%{begin:%H:%M:%S}t.%{begin:msec_frac}t -> %{end:%H:%M:%S}t.%{end:msec_frac}t \"%r\" %>s" timing
    CustomLog /proc/self/fd/1 timing

    # A page that takes 1 second to build, standing in for PHP and the database
    ScriptAlias /slow.cgi /usr/local/apache2/cgi-bin/slow.cgi
    # The same page with no hints, for comparison
    ScriptAlias /plain.cgi /usr/local/apache2/cgi-bin/slow.cgi

    # Sent as a 103 before the script starts
    <Location "/slow.cgi">
        H2EarlyHint Link "</style.css>; rel=preload; as=style"
    </Location>

    # Hinted files must be cacheable: Chrome keeps them in its HTTP cache
    <Files "style.css">
        Header set Cache-Control "public, max-age=3600"
    </Files>

    # Lets .htaccess files in /shared add their own hints
    <Directory "/usr/local/apache2/htdocs/shared">
        AllowOverride FileInfo
    </Directory>
</VirtualHost>

The script is a pause and a print:

#!/bin/sh
sleep 1
printf 'Content-Type: text/html\r\n\r\n'
cat /usr/local/apache2/htdocs/page.html

We requested the page with curl 8.7.1 over HTTP/2. The -k flag accepts our test certificate; leave it out on a real site.

curl -sk --http2 -D - -o /dev/null https://localhost:8443/slow.cgi

HTTP/2 103
link: </style.css>; rel=preload; as=style

HTTP/2 200
content-type: text/html
date: Wed, 21 Oct 2026 14:12:33 GMT
server: Apache/2.4.69 (Unix) OpenSSL/3.5.7

The 103 is the separate block at the top. Over HTTP/1.1, the same request got no 103 at all, because mod_http2 only sends one on HTTP/2 connections:

curl -sk --http1.1 -D - -o /dev/null https://localhost:8443/slow.cgi

HTTP/1.1 200 OK
Date: Wed, 21 Oct 2026 14:12:34 GMT
Server: Apache/2.4.69 (Unix) OpenSSL/3.5.7
Upgrade: h2
Connection: Upgrade
Transfer-Encoding: chunked
Content-Type: text/html

Next we loaded the page in headless Chrome 155. Apache’s log shows what the browser did with the hint:

14:12:39.064 -> 14:12:39.065 "GET /style.css HTTP/2.0" 200
14:12:39.060 -> 14:12:40.069 "GET /slow.cgi HTTP/2.0" 200

Chrome asked for style.css 4 ms after it asked for the page. It had the file 1,004 ms before the page finished, and it never requested it again. Chrome’s own timing data agreed: it marked the stylesheet’s initiator as early-hints and recorded 0 bytes transferred when the page used it.

Look for the separate Early hints headers section: it shows what the 103 carried before the 200. Chrome 155 DevTools on our Apache 2.4.69 test page, captured 21 October 2026.

One detail matters if you repeat this. Chrome’s guide says it disables the HTTP cache for untrusted certificates, which would waste the preload. We told that Chrome instance to trust our test key with the --ignore-certificate-errors-spki-list flag.

How to Turn On Early Hints, by Platform

Where you switch it on depends on what answers your visitors first. If a CDN sits in front of your site, start there, because it can send the 103 while it waits for your server. On your own server you need HTTP/2 and access to the server configuration.

Cloudflare: Every Plan, One Switch

1. In the Cloudflare dashboard, go to Speed > Settings.
2. Open the Content Optimization tab.
3. Turn Early Hints on.

Cloudflare’s documentation, last updated on 17 September 2026, lists Early Hints on the Free, Pro, Business and Enterprise plans. What matters is where the hints come from. Cloudflare doesn’t read your HTML. It caches the preload and preconnect Link headers your server sends with a page, then replays them as a 103 on later requests.

That only happens for 200, 301 and 302 responses, on URLs that end in .html, .htm or .php or have no extension. The hint cache is keyed by URL and ignores query strings. Cloudflare sends the 103 over HTTP/2 and HTTP/3 only.

Three behaviours surprise people. A page Cloudflare already holds in its cache can answer before the hint lookup finishes, and then no 103 goes out. On pages behind a login, a visitor without access can still get the 103 before the 403. And Cloudflare turns Early Hints off for some search crawlers that mishandle 1xx responses.

WordPress owners need one more piece. A default WordPress 7.1.3 install sends no preload headers: our test site’s homepage sent only WordPress’s REST API Link header. Cloudflare then has nothing to cache, so the switch alone does nothing. The plugins further down fix that. If your site isn’t on Cloudflare yet, our guide to adding Cloudflare to WordPress covers the setup.

On Kinsta, the switch sits in MyKinsta under WordPress Sites > your site > Tools, on the Early Hints tile. Kinsta says it runs through its Cloudflare integration.

Fastly and Akamai

Fastly sends a 103 from edge code. In VCL, you call the early_hints() function with the Link headers you want, and Fastly’s reference says to call it in vcl_recv. Called in vcl_deliver, the hint reaches the browser together with the main headers, which defeats the point. It only works for clients on HTTP/2 or later.

Akamai offers an Early Hints behavior in Property Manager for its Ion and Dynamic Site Accelerator products. You enter the Link values, and Akamai sends them only when the request carries Sec-Fetch-Mode: navigate, over HTTP/2 or HTTP/3. The default size limit for the 103’s headers is 3 KB.

Shopping for a CDN that does this for you? Our comparison of CDN hosting providers covers the main options and their free tiers.

Apache 2.4.58 or Later

Apache needs two directives from mod_http2. H2EarlyHints on allows 103 responses at all; it’s off by default and works only in the server config or a virtual host. H2EarlyHint adds a header to the 103, and it needs Apache 2.4.58 or later.

The mod_http2 documentation explains the default: “a range of clients still have trouble with unexpected interim responses”. Our test above used both directives, with the hint inside a <Location> block.

On shared hosting, H2EarlyHint also works in .htaccess, if your host allows it. In our test it worked once the folder had AllowOverride FileInfo. This was the whole .htaccess file:

H2EarlyHint Link "</style.css>; rel=preload; as=style"

curl -sk --http2 -D - -o /dev/null https://localhost:8443/shared/

The output, with the date, server, ETag, Last-Modified, Accept-Ranges and size lines removed:

HTTP/2 103
link: </style.css>; rel=preload; as=style

HTTP/2 200
link: </style.css>; rel=preload; as=style
content-type: text/html

Watch for a false positive here. When we switched H2EarlyHints off at server level, the same .htaccess line still put the Link header on the 200, but no 103 went out. A quick header check would look fine. Look for the separate HTTP/2 103 block instead.

Nginx 1.29.0 or Later

Nginx added the early_hints directive in mainline version 1.29.0 on 24 June 2025. Stable nginx 1.30.0 brought the directive to production servers on 14 April 2026, and older versions reject a config that uses it.

Nginx doesn’t create a 103 itself. It passes one on from the application behind it, and by default it drops it. The changelog names proxy and gRPC backends. FastCGI isn’t listed, so a classic Nginx and PHP-FPM WordPress stack has no documented way to pass a 103 on.

We tested the directive on nginx 1.30.6 (the nginx:stable image) in front of a small Node.js 22 backend. The map block is the one in the early_hints documentation:

# Pass a 103 on only to browser navigations over HTTP/2 or HTTP/3
map $http_sec_fetch_mode $early_hints {
    navigate $http2$http3;
}

server {
    listen 443 ssl;
    http2 on;
    ssl_certificate     /etc/nginx/certs/server.crt;
    ssl_certificate_key /etc/nginx/certs/server.key;

    location / {
        early_hints $early_hints;
        proxy_pass http://eh-node-backend:3000;
    }
}

The backend sends the 103 itself, then the page a second later:

// Test backend: sends a 103 at once, then the page after 1 second
const http = require('http');
http.createServer((req, res) => {
  res.writeEarlyHints({ link: '</style.css>; rel=preload; as=style' });
  setTimeout(() => {
    res.writeHead(200, { 'content-type': 'text/html' });
    res.end('<!doctype html><link rel="stylesheet" href="/style.css"><p>hello</p>\n');
  }, 1000);
}).listen(3000);

A request with the header Chrome sends on a navigation got the 103:

curl -sk --http2 -H "Sec-Fetch-Mode: navigate" -D - -o /dev/null https://localhost:8444/

HTTP/2 103
link: </style.css>; rel=preload; as=style

HTTP/2 200
server: nginx/1.30.6
date: Wed, 21 Oct 2026 14:01:33 GMT
content-type: text/html

The same request without that header got only the 200, which is the map doing its job:

curl -sk --http2 -D - -o /dev/null https://localhost:8444/

HTTP/2 200
server: nginx/1.30.6
date: Wed, 21 Oct 2026 14:01:34 GMT
content-type: text/html

With the early_hints line removed, Nginx dropped the backend’s 103 on every request. That’s the first thing to check if your app sends hints and the browser never sees them.

Your Linux distribution may hold you back. Debian 13 ships Nginx 1.26.3 and Ubuntu 24.04 ships 1.24.0. Ubuntu 26.04 LTS, released on 23 April 2026, ships 1.28.3. None of them knows the directive, and here’s what nginx 1.28.3 printed in our test:

nginx: [emerg] unknown directive "early_hints" in /tmp/t.conf:1
nginx: configuration file /tmp/t.conf test failed

The fix is the nginx.org package repository, whose stable branch had 1.30.6 for Ubuntu 26.04 on the day we checked. On shared hosting you can’t change the Nginx version. On an unmanaged VPS you can.

LiteSpeed: No Documented Support

If your host runs LiteSpeed, this gap matters. We found no mention of Early Hints or a 103 response in LiteSpeed’s documentation. Its LiteSpeed Web Server release log doesn’t mention it either, up to version 6.4.0 RC2 of 23 September 2026. Neither does the OpenLiteSpeed 1.9 log, up to 1.9.3 of 29 September 2026.

We also found nothing saying LiteSpeed honours Apache’s H2EarlyHint directive, and we couldn’t test the licensed server. On LiteSpeed hosting, the documented route is a CDN in front, such as Cloudflare, fed by Link headers from your site.

WordPress Plugins: What They Actually Send

The plugins we looked at take one of two routes. They add Link headers for Cloudflare to cache, or they write Apache directives. We installed two free ones on a test site running WordPress 7.1.3, PHP 8.3.35 and Apache 2.4.68 from the official wordpress image.

• App for Cloudflare (version 1.10.1.1, 1,000+ active installs) has a “Preload resources” option that’s on by default. In our test it added Link: <http://localhost:8088/wp-content/eh-test.css?ver=1>;as=style;rel=preload to the 200, naming the stylesheet our test page loaded. Its settings page says it lists at most 10 resources. That’s the input Cloudflare needs, though we couldn’t test Cloudflare’s side locally.
• ezCache (version 2.6.5, 10,000+ active installs) lists “103 Early Hints” as a feature. In our test, switching it on produced no 103 and no preload header. Its code points to the reason. It sends its headers on WordPress’s send_headers hook, which fires before the page’s stylesheets are queued, so its list is still empty.
• Perfmatters, a paid plugin, has a Cloudflare Early Hints option under Preloading, according to its documentation. It adds a hint for each file you preload in the plugin, and Perfmatters says Cloudflare is required. We didn’t test it.
• Easy HTTP 103 (fewer than 10 active installs) takes the Apache route. Its code writes H2EarlyHint lines into .htaccess and checks for Apache newer than 2.4.57, so your host still has to switch H2EarlyHints on. We didn’t test it.

Which Hosting Companies Send Early Hints? We Checked 31

Plenty of hosts sell speed, so we checked how many use Early Hints on their own homepage. On 21 October 2026, between 14:02 and 14:03 UTC, we sent one request to each of 31 hosting homepages from our roundups.

Each request used HTTP/2 and the headers Chrome sends when you open a page, including Sec-Fetch-Mode: navigate and a Chrome 155 user agent. That matters because servers that follow Chrome’s advice only answer real navigations with a 103, as our Nginx test showed. We didn’t follow redirects.

Two of the 31 sent a 103: Cloudflare’s own site and DreamHost. Seventeen answered with a normal 200 and no 103. Six redirected us without one, and six blocked the request with a 403, so they tell us nothing.

Cloudflare’s reach makes that low count stand out. Of the 31 homepages, 23 came through Cloudflare, where Early Hints is a free switch. Two of those 23 sent a 103, 13 answered with a plain 200, and the rest redirected or blocked us.

Kinsta is the clearest case. It offers Early Hints to its customers through MyKinsta, but its own homepage sent no 103. Its 200 carried no preload Link header either, so Cloudflare had nothing to replay.

Both 103s preloaded fonts with the crossorigin attribute. DreamHost’s named six font files. Cloudflare’s named two fonts, two preconnects and its hero image, marked fetchpriority=high.

Read the table with one limit in mind. It’s one request per site, and Cloudflare often skips the 103 when a cached page is ready first. “No 103” means none on our request, not that a setting is off.

The wider web looks much the same. HTTP Archive’s 2024 Web Almanac found Early Hints on 2.9% of desktop pages, and Shopify accounted for 2.6 points of that. Its 2025 edition put usage at roughly 4%.

Traps That Cancel the Gain

A 103 that goes out isn’t the same as a faster page. These are the traps we either reproduced or found in the vendors’ own documentation.

HTTP/1.1 connections: Chrome and Safari act on a 103 only over HTTP/2 or later, and neither of our test servers sent one over HTTP/1.1. RFC 8297 explains the caution. An old HTTP/1.1 client can mistake the 103 for the final response and then misread later responses on the same connection.

A proxy that drops it: Nginx without early_hints silently dropped the backend’s 103 in our test. Check every layer between the visitor and your app, and test from outside your network.

Files that can’t be cached: We hinted a stylesheet served with Cache-Control: no-store. Chrome downloaded it twice. Once from the hint, and again 1,013 ms later, after the HTML arrived.

Hints for the wrong files: Chrome’s guide warns about versioned file names. If the 103 names main.abcd100.css but the page uses main.abcd105.css, the download is wasted. Too many hints hurt as well. In Cloudflare’s 2022 study, one page hinted over 50 images and none of its render-blocking scripts. It got faster on a cable profile and slower on the slow mobile ones.

A TTFB that looks too good: TTFB (time to first byte) is how fast the server starts answering. Since Chrome 133 (4 February 2025), the responseStart timing that most tools report as TTFB counts the 103. Google’s web.dev TTFB guide says so plainly: “The 103 Early Hints counts as the ‘first bytes'”.

In our test, curl’s first-byte time was 0.013 s with the hint and 1.024 s without it, on the same 1-second page. Total time was about 1.02 s both ways. Use finalResponseHeadersStart in Chrome to see when the real page arrived.

Fonts on another origin: Fonts always load as CORS requests (cross-origin requests that need the other server’s permission), and CORS requests use a separate connection. That’s why MDN’s example preconnects to the same origin twice, once with crossorigin. In our Chrome 155 test, a font preload to another origin was used once, with or without the attribute.

What to Put in a 103

Chrome’s guide says to start with your top landing pages, where visitors arrive with an empty cache. By the second or third page, the browser usually has the shared files already.

Pick files that block the first paint: the main stylesheet, a synchronous script, the web font your headings use. Add a preconnect for each third-party origin that serves your largest image or your fonts. In HTML, a preload is for files the browser finds late. In a 103 there’s no HTML yet, so even main.css is worth naming.

Choose URLs that don’t change with every deploy. Chrome suggests splitting CSS into a stable file for the 103 and a changing file for the page itself. Keep the same Link headers on the final 200 too, for browsers and CDNs that read them there. If your largest image is the main target, start with a normal preload of your LCP image in the page head.

Keep expectations modest. Cloudflare’s 2022 study covered about 750 URLs. Half of the desktop pages improved first paint by more than 9.47% and LCP by more than 6.03%. The best quarter improved first paint by over 20.4% and LCP by over 15.97%. Chrome’s guide cites gains of several hundred milliseconds seen by Shopify and Cloudflare.

Advice You’ll Still Find That’s Out of Date

Our own 2023 version of this page repeated several of these claims. Each one is wrong today, or was never supported.

“Sign up for the beta.” Cloudflare’s post of 16 September 2021 did ask for that. By 23 June 2022, its instructions were a plain switch, and today it sits under Speed > Settings > Content Optimization on every plan.

“Test in Chrome 94 with a flag.” That was the origin trial. Chrome 103 needs no flag. Cloudflare’s own Early Hints page still names “Google Chrome M94 and higher” as an example, a leftover from 2021.

“It improves SEO rankings.” Google’s search documentation lists three Core Web Vitals: LCP, INP and CLS. None of them measures the 103 itself. The only route to rankings is indirect, through a faster LCP on pages that are slow to build.

“Every page loads faster.” Chrome’s guide says Early Hints isn’t useful when the server can send the 200 right away. A cached page doesn’t gain anything.

“Up to 30% faster.” That figure came from Cloudflare’s first lab tests in 2021. Its 2022 study found a median desktop LCP gain of just over 6%.

Crawler Hints is a different Cloudflare feature. It tells search engines, through IndexNow, when your content has likely changed. It doesn’t make pages load faster.

Frequently Asked Questions

What does HTTP response code 103 mean?

It means “Early Hints”. It’s a preliminary response that arrives before the real one, carrying Link headers. The browser uses them to download files or open connections early. The final status, such as 200, follows on the same request.

Do I need to change my WordPress site to use Cloudflare Early Hints?

Yes. Cloudflare builds its 103 from preload and preconnect Link headers your server sends. A default WordPress install sends none. Add a plugin that sends them, such as App for Cloudflare, then turn Early Hints on in Cloudflare.

Can I use Early Hints on LiteSpeed hosting?

Not from LiteSpeed itself, as far as its documentation shows. We found no mention of Early Hints in LiteSpeed’s docs or release logs up to September 2026. Put Cloudflare in front, and send Link headers from your site.

Does Amazon CloudFront support 103 Early Hints?

AWS doesn’t document it. The CloudFront developer guide never mentions a 103. It says that after a 100-Continue response, CloudFront expects a 200. If you need Early Hints at the edge, Cloudflare, Fastly and Akamai all document it.

Should You Turn It On?

Turn it on when your HTML takes a few hundred milliseconds or more to build. Uncached WordPress pages, WooCommerce carts and logged-in dashboards fit that, as long as you hint a handful of render-blocking files.

On Cloudflare, that means the switch plus a plugin that sends Link headers. On your own Apache 2.4.58 or later, it means H2EarlyHints on and an H2EarlyHint line per landing page. On Nginx, it means version 1.29.0 or later and an app that sends the 103 itself.

Skip it when your pages come from a cache in milliseconds, when your server only speaks HTTP/1.1, or on LiteSpeed with no CDN in front. In those cases a normal <link rel="preload"> in the page head does the same work with less to break.