HTTP/2 is a major upgrade to the way data is transferred on the web. Compared to the older HTTP/1.1 protocol, it brings faster page loads, better handling of multiple requests, and improved overall efficiency. If you care about site speed, SEO, or user experience, making sure your website uses HTTP/2 is a smart move.

But how can you tell if your site is actually using it?

In this guide, we’ll walk you through simple ways to check whether HTTP/2 is enabled — using browser tools, free online checkers, and command-line methods. Whether you’re a developer, SEO specialist, or just managing a site, you’ll be able to verify HTTP/2 support in under 5 minutes.

📊 Did you know? As of 2025, over 77% of all websites use HTTP/2 globally (W3Techs). However, many still unknowingly serve parts of their site via HTTP/1.1 due to misconfigured proxies, CDNs, or legacy server setups.

How HTTP/2 Improves Speed and SEO

HTTP/2 was developed to address key performance bottlenecks in HTTP/1.1. It allows multiple file requests to be sent simultaneously over a single connection, eliminating the blocking behavior that slows down web pages.

Key performance benefits:

  • Multiplexing: Multiple files (HTML, CSS, JS, images) are loaded in parallel over one connection.
  • Header compression: Reduces overhead by compressing repetitive request headers.
  • Request prioritization: Critical resources are loaded before non-essential ones.

These improvements lead to measurable speed gains.

According to Google, websites using HTTP/2 can see load time improvements of up to 50% on mobile devices. Akamai’s large-scale testing found that HTTP/2 reduced page load times by an average of 29% across various websites.

Beyond user experience, speed also affects your search rankings. Google includes page performance in its algorithm, and HTTP/2 directly impacts metrics like:

  • Time to First Byte (TTFB)
  • Largest Contentful Paint (LCP)
  • First Input Delay (FID)

Sites that still use HTTP/1.1 risk slower load times, lower SEO visibility, and weaker engagement.

How to Check HTTP/2 Support Using Browser DevTools

The fastest way to check if your website is using HTTP/2 is through your browser’s built-in developer tools. Most modern browsers display the protocol used for each network request.

Google Chrome or Chromium-based browsers:

  1. Open your website in a new tab.
  2. Press F12 or right-click and select Inspect to open DevTools.
  3. Go to the Network tab.
  4. Reload the page (Ctrl+R or Cmd+R).
  5. Look for the Protocol column. If you don’t see it:
    • Right-click on the column headers and enable Protocol.

You should see h2 listed for requests using HTTP/2. If it says http/1.1, your site is not currently using HTTP/2.

Mozilla Firefox:

  1. Open your site and press F12 to launch DevTools.
  2. Go to the Network tab.
  3. Reload the page.
  4. In the list of requests, look for the Transferred or Protocol column — it should indicate h2 for HTTP/2.

Example:

When loading a properly configured site, you’ll see something like:

https://yourdomain.com – h2 – 200 OK

If most resources show http/1.1, it likely means HTTP/2 is either not enabled or is blocked by a proxy or CDN.

How to Check HTTP/2 Support Using Free Online Tools

If you don’t want to use browser DevTools or need a quick external check, several free online tools can tell you whether a website supports HTTP/2. These tools run remote tests and are useful for checking public-facing configurations without needing server access.

1. KeyCDN HTTP/2 Test

  • URL: https://tools.keycdn.com/http2-test
  • Just enter your domain name and press “Test”.
  • The result will show if the server supports HTTP/2 and whether it’s properly negotiated over TLS.

Example Result:

https://example.com
HTTP/2 Supported: Yes
Protocol: h2

2. Geekflare HTTP/2 Test

  • URL: https://gf.dev/http2-test
  • Also provides a quick confirmation of HTTP/2 support and TLS details.
  • Useful for testing edge cases like CDN or proxy configurations.

3. WebPageTest.org

  • URL: https://webpagetest.org
  • Offers full waterfall charts and performance breakdowns.
  • In the connection details, it shows the protocol used for each resource (e.g., h2, http/1.1).
  • Ideal for seeing if some resources are being downgraded.

These tools are helpful for spot-checking any site, whether you own it or are analyzing competitors. However, they rely on publicly visible behavior — if you use internal proxies, staging domains, or non-standard ports, you’ll need to test locally too.

How to Check HTTP/2 Support Using Command-Line Tools

If you’re comfortable with the terminal, command-line tools offer a fast and scriptable way to test HTTP/2 support. This is especially useful for automation, CI/CD pipelines, or when testing staging environments.

1. Curl

Most modern versions of curl support HTTP/2 testing.

Command:

curl -I --http2 https://yourdomain.com
  • -I requests only the headers.
  • --http2 forces curl to use HTTP/2 if the server supports it.

What to look for:
In the response headers, check the HTTP/2 200 line at the top. If you see HTTP/1.1 200 OK instead, the server isn’t using HTTP/2.

You can also run:

bashКопіюватиРедагуватиcurl -I -v https://yourdomain.com

This shows detailed connection info. Look for:

* Using HTTP2, server supports multi-use

Note: Make sure you have curl 7.47.0 or higher to support HTTP/2.

2. OpenSSL

To inspect lower-level TLS protocol negotiation.

Command:

openssl s_client -connect yourdomain.com:443 -alpn h2
  • -alpn h2 asks the server if it supports HTTP/2.
  • Look for a line in the output: 
ALPN protocol: h2

If you see ALPN protocol: http/1.1, then HTTP/2 is not being negotiated.

These methods are powerful because they remove the browser layer from testing. They let you directly verify how the server is configured and how protocols are negotiated over TLS.

How to Confirm HTTP/2 Support in Server and CDN Configuration

If your tests show that HTTP/2 isn’t enabled, or only partially enabled, the next step is to check your server and CDN configuration. Misconfigurations at the server or edge level often block proper HTTP/2 negotiation, even if your platform technically supports it.

NGINX

HTTP/2 support must be explicitly enabled in the SSL configuration block.

Example:

server {
    listen 443 ssl http2;
    ...
}

Make sure the http2 directive is included. If only ssl is present, it will default to HTTP/1.1.

To verify:

nginx -V

Look for --with-http_v2_module in the compile flags.

Apache

HTTP/2 requires mod_http2 and must be enabled in both the config and the virtual host.

In httpd.conf:

LoadModule http2_module modules/mod_http2.so

In your virtual host:

Protocols h2 http/1.1

Apache 2.4.17 or later is required for stable HTTP/2 support.

Cloudflare

Cloudflare enables HTTP/2 by default on all plans, but it can be disabled manually.

To check:

  1. Go to the Speed tab in the Cloudflare dashboard.
  2. Under Optimization, ensure HTTP/2 is turned on.

AWS CloudFront

HTTP/2 is supported but must be enabled per distribution.

  • Go to your distribution settings.
  • In the “Behaviors” tab, make sure HTTP/2 is selected under Viewer Protocol Policy.

Other CDNs (Akamai, Fastly, etc.)

  • Look for protocol settings in the dashboard.
  • HTTP/2 is usually enabled by default, but still verify using curl or online tools.

If HTTP/2 appears enabled in your server config but your tests still return HTTP/1.1, the issue is likely due to a proxy, load balancer, or TLS negotiation misconfiguration.

Common Pitfalls That Prevent HTTP/2 From Working

Even if HTTP/2 is enabled in your server or CDN settings, it doesn’t guarantee that all traffic will use it. These are some of the most common reasons why HTTP/2 fails to function as expected:

1. Missing TLS (HTTPS)

Most browsers only allow HTTP/2 over secure connections (TLS). If your site supports HTTP/2 but still serves content over plain HTTP, browsers will default to HTTP/1.1.

According to Google’s Transparency Report, over 95% of web traffic on Chrome in the U.S. uses HTTPS. Without HTTPS, HTTP/2 will not be used by the majority of browsers.

2. Proxy or Load Balancer Downgrades

If you’re using reverse proxies (e.g., HAProxy, NGINX in front of Apache) or load balancers, they can unintentionally strip or downgrade HTTP/2 to HTTP/1.1 between hops.

  • Example: Cloudflare → NGINX (h2) → legacy Apache (http/1.1)

Make sure every layer in the delivery chain is HTTP/2-compatible and properly configured.

3. Inconsistent CDN Settings

Your origin might support HTTP/2, but your CDN may serve cached assets via HTTP/1.1 if it’s not correctly set up.

  • Check: Your CDN should advertise h2 in the ALPN (Application-Layer Protocol Negotiation) during TLS handshakes.

4. Server Misconfiguration

Common mistakes:

  • listen 443 ssl; instead of listen 443 ssl http2; in NGINX
  • Missing Protocols h2 http/1.1 in Apache
  • Disabling mod_http2 by mistake

Always verify your server startup logs or use diagnostic commands (nginx -V, apachectl -M).

5. Outdated Browsers or Clients

Very old browsers or curl versions may not support HTTP/2. If you’re testing with legacy tools, update to recent versions to avoid false negatives.

How to Fix HTTP/2 Issues

If your site isn’t fully leveraging HTTP/2, resolving the problem usually comes down to correcting server or infrastructure configuration. Below are practical steps based on common failure points.

1. Enable HTTPS Site-Wide

Since most browsers only allow HTTP/2 over secure connections, the first step is ensuring HTTPS is enabled across your entire domain.

  • Use a valid TLS certificate from Let’s Encrypt or a commercial provider.
  • Redirect all HTTP traffic to HTTPS.
  • Test using SSL Labs: https://www.ssllabs.com/ssltest/

2. Update Web Server Configuration

Ensure HTTP/2 is explicitly enabled:

NGINX:

listen 443 ssl http2;

Apache:

Protocols h2 http/1.1

Also make sure:

  • Modules like mod_http2 (Apache) or --with-http_v2_module (NGINX) are active.
  • You reload the configuration after changes: 
sudo systemctl reload nginx

3. Check Reverse Proxies and Load Balancers

If your traffic flows through Cloudflare, HAProxy, or another reverse proxy, confirm that:

  • HTTP/2 is enabled both at the edge and between your services.
  • No protocol downgrade occurs between CDN → Proxy → App server.

4. Clear Caches and Use Fresh Tests

Some browsers cache old protocol preferences. If you’ve recently enabled HTTP/2:

  • Clear browser cache or use Incognito mode.
  • Use tools like curl or WebPageTest.org to confirm from an external point of view.

5. Use Diagnostic Tools

  • Run curl -I --http2 https://yourdomain.com to verify the protocol response.
  • Run Lighthouse or WebPageTest to confirm that resources load via HTTP/2 and evaluate load time impact.

A study by Cloudflare found that enabling HTTP/2 reduced Time To First Byte (TTFB) by 27% for HTML and static assets in real-world scenarios.

Conclusion and Next Steps

Verifying HTTP/2 support is a quick win for improving site performance, especially on mobile and content-heavy pages. Whether you’re running a blog, SaaS product, or e-commerce store, enabling HTTP/2 helps reduce load times, improves Core Web Vitals, and contributes to better SEO results.

To summarize:

  • Use browser DevTools to check protocol usage in real time.
  • Run remote tests with tools like KeyCDN and Geekflare.
  • Use curl or OpenSSL to inspect protocol negotiation from the terminal.
  • Fix configuration issues at the server, CDN, or proxy level.

According to W3Techs, as of May 2025, 77.4% of websites use HTTP/2. Yet many still misconfigure parts of their stack, serving critical content over outdated protocols.

Ensuring your entire site uses HTTP/2 consistently is essential if you want to stay competitive in a speed-sensitive, search-driven web.

Q1: How can I tell if my site is using HTTP/2?

You can check by using browser DevTools, online tools like KeyCDN’s HTTP/2 test, or command-line tools such as curl. If your site serves traffic with the h2 protocol, it uses HTTP/2.

Q2: What does it mean if some resources are still using HTTP/1.1?

This usually indicates a configuration issue at the CDN, proxy, or server level. While HTTP/2 might be enabled on the main domain, some assets might still be served from endpoints that don’t support it.

Q3: Do I need HTTPS to use HTTP/2?

Yes. All major browsers require HTTPS for HTTP/2. Enabling TLS across your site is essential for HTTP/2 to function correctly.

Q4: Can HTTP/2 improve SEO?

Yes. HTTP/2 reduces load times and improves Core Web Vitals, which are part of Google’s ranking signals. Faster pages can lead to better user experience and higher search visibility.

Q5: What tools are best for checking HTTP/2 performance?

Popular tools include Lighthouse, WebPageTest, KeyCDN HTTP/2 Test, and curl with the --http2 flag. Each provides visibility into protocol usage and performance metrics.