HTTP2 Protocol Error​

You open a website in Chrome and instead of the page you expected, you see a blank screen with the message ERR_HTTP2_PROTOCOL_ERROR. No explanation. No obvious fix. Just a cryptic error code that tells you almost nothing about what went wrong or how to fix it.

The frustrating truth is that this error has multiple possible causes — and whether you are a regular user visiting a website, or a business owner running one, the fix depends on where the breakdown is happening. It might be your browser cache. It might be a browser extension. It might be your hosting server’s SSL configuration. Or it might be a firewall on your network quietly interfering with the connection.

This guide walks through every major cause of HTTP/2 protocol errors and every tested fix — starting with the quick browser-side solutions that resolve the problem in most cases, then moving into WordPress-specific fixes, server configuration steps for nginx and Apache, and finally network and firewall issues for more complex environments.

---

What Is an HTTP/2 Protocol Error?

HTTP/2 is the modern version of the protocol that browsers and web servers use to communicate. It replaced HTTP/1.1 as the dominant protocol for the web, bringing faster performance through features like multiplexed streams (multiple requests over a single connection), header compression, and server push. For most websites, it operates invisibly — you never notice it is there.

A “protocol error” occurs when the rules of HTTP/2 communication are violated. The browser and server are supposed to follow a strict set of rules when exchanging data. When something breaks those rules — a malformed header, an unexpected connection close, an SSL negotiation failure — the connection collapses and the browser reports an error.

In Google Chrome, this appears as ERR_HTTP2_PROTOCOL_ERROR. Other browsers report the same underlying problem with slightly different messages:

• Chrome / Edge: ERR_HTTP2_PROTOCOL_ERROR
• Firefox: “The connection was reset” or NS_ERROR_NET_INADEQUATE_SECURITY
• Safari: “Safari can’t open the page” (less specific error reporting)

Regardless of which browser you use, if the page loads fine in one browser but not another, that is a strong signal the problem is on the browser side. If no browser can load the page, the problem is more likely server-side.

---

What Causes HTTP/2 Protocol Errors?

HTTP/2 protocol errors have a range of causes. They fall into four broad categories: browser and device issues, server and SSL configuration problems, CDN and proxy interference, and network/firewall interference. Understanding which category applies to your situation tells you where to start troubleshooting.

Browser Cache and Session Data

Your browser stores HTTP/2 session information to speed up repeat visits. If this cached data becomes stale or corrupted — after a server upgrade, for example — the browser may try to resume an HTTP/2 connection that no longer exists on the server side. Clearing the cache forces a fresh connection and resolves this in many cases.

Browser Extension Conflicts

Browser extensions sit between your browser and the websites you visit. VPNs, ad blockers, download managers, and privacy tools can all interfere with how HTTP/2 connections are established or maintained. An extension that worked fine for years can start causing this error after an update, or after a website updates its own configuration.

QUIC Protocol Incompatibility

Chrome uses a feature called QUIC (the basis for HTTP/3) that can conflict with HTTP/2 fallback on certain server configurations. When QUIC negotiation fails and the fallback to HTTP/2 does not work correctly, Chrome reports an ERR_HTTP2_PROTOCOL_ERROR. Approximately 8% of websites support QUIC, meaning most server configurations are not tested against it thoroughly.

SSL/TLS Certificate Problems

HTTP/2 in browsers is effectively HTTPS-only. Any problem with your SSL certificate — expired, using an incomplete certificate chain, or a misconfigured TLS version — can cause HTTP/2 to fail before a connection is even established. An incomplete certificate chain is one of the most common server-side causes: the server sends its own certificate but omits the intermediate certificates needed to verify it, causing the browser to reject the connection.

Server Misconfiguration

Web servers need specific configuration to support HTTP/2 correctly. Nginx requires the http2 keyword in its listen directive. Apache requires the mod_http2 module to be loaded and the Protocols h2 http/1.1 directive to be set. If these are missing or incorrectly configured, the server cannot complete HTTP/2 handshakes. There is also a known nginx issue where a Content-Security-Policy header split across multiple lines in the config file triggers HTTP/2 protocol errors.

Antivirus and Security Software

Many antivirus programs perform HTTPS inspection by acting as a man-in-the-middle proxy for your browser’s connections. This proxy intercepts the HTTP/2 connection and re-establishes it — but many antivirus HTTPS inspection engines do not fully support HTTP/2’s binary framing layer. The result is a broken HTTP/2 connection reported as ERR_HTTP2_PROTOCOL_ERROR. Specific products known to cause this include Avast, Kaspersky, Bitdefender, and ESET.

Firewall and Network Interference

Corporate firewalls, school networks, and some home security appliances perform deep packet inspection on HTTPS traffic. This process can strip ALPN (Application-Layer Protocol Negotiation) headers — the mechanism that tells the server the browser wants to use HTTP/2. Without a valid ALPN negotiation, HTTP/2 cannot be established. This is especially common on enterprise networks after firewall firmware upgrades.

CDN and Reverse Proxy Problems

Services like Cloudflare, Nginx reverse proxies, and load balancers sit between your browser and the origin server. Misconfiguration at this layer — particularly Cloudflare’s SSL mode being set to “Flexible” instead of “Full (Strict)” — can create protocol mismatches that surface as HTTP/2 errors. The browser negotiates HTTP/2 with Cloudflare, but Cloudflare then uses HTTP/1.1 or an incompatible TLS setting to talk to the origin, causing an inconsistency that breaks the stream.

The table below summarises all major causes at a glance:

Cause	Who It Affects	Frequency	Fix Difficulty
Stale browser cache / HTTP/2 session data	End users visiting a site	Very common	Easy
Browser extension conflict (VPN, ad blocker)	End users	Common	Easy
QUIC / HTTP/3 protocol conflict	End users (Chrome/Edge)	Common	Easy
Outdated browser version	End users	Common	Easy
Antivirus HTTPS inspection interference	End users with AV software	Common	Moderate
SSL certificate expired or incomplete chain	Website visitors + site owners	Common	Moderate
Nginx/Apache HTTP/2 misconfiguration	Server admins / site owners	Moderate	Moderate
Cloudflare SSL mode set to Flexible	WordPress / site owners using Cloudflare	Moderate	Easy
Firewall ALPN stripping	Corporate / school network users	Less common	Hard (admin required)
Nginx CSP header on multiple lines	Server admins	Less common	Easy once identified

---

How to Fix ERR_HTTP2_PROTOCOL_ERROR in Your Browser

If you are a visitor seeing this error on a website — and the site works for other people — the problem is almost certainly on your side. Work through these fixes in order. Most people resolve the issue with the first two steps.

Fix 1: Hard Refresh and Clear Browser Cache

A hard refresh bypasses cached page data and requests fresh content from the server. This is the fastest first step.

• Windows: Press Ctrl + Shift + R
• Mac: Press Cmd + Shift + R

If the hard refresh does not work, clear the full browser cache:

• Chrome: Menu (three dots) > Settings > Privacy and Security > Clear browsing data > check “Cached images and files” > Clear data
• Firefox: Menu > Library > History > Clear recent history > select “Cache” > OK
• Edge: Settings > Privacy, search, and services > Clear browsing data > Cached images and files

For Chrome specifically, also flush the socket pool to clear HTTP/2 session data: navigate to chrome://net-internals/#sockets and click Flush socket pools. This clears any stale HTTP/2 connection state that clearing the regular cache may miss.

Fix 2: Test in Incognito / Private Mode

Open an incognito window (Chrome: Ctrl + Shift + N / Firefox: Ctrl + Shift + P) and try loading the page again. Incognito mode starts with a clean cache and no extensions enabled. If the page loads in incognito but not in your regular browser window, the problem is a browser extension or cached data.

Fix 3: Disable Browser Extensions

If incognito mode resolves the error, identify which extension is causing the conflict:

1. Open Chrome’s extension manager: Menu > More Tools > Extensions (or navigate to chrome://extensions)
2. Disable all extensions by toggling each one off
3. Reload the problem page
4. Re-enable extensions one at a time, reloading the page each time, until the error returns

Common culprits: VPN extensions, ad blockers (uBlock Origin, AdBlock), privacy extensions (Privacy Badger), download managers, and security extensions. Note that the extension itself may not be the problem — sometimes a combination of extensions causes the conflict.

Fix 4: Disable the QUIC Protocol in Chrome

Chrome’s experimental QUIC protocol (the basis for HTTP/3) can conflict with HTTP/2 on certain server configurations, producing this error. Disabling QUIC forces Chrome to fall back to standard HTTP/2 and HTTP/1.1:

1. Type chrome://flags in the address bar and press Enter
2. Search for Experimental QUIC protocol
3. Change the setting from “Default” to Disabled
4. Click Relaunch to restart Chrome

This is a diagnostic step as much as a fix. If disabling QUIC resolves the error, the issue is a protocol negotiation failure between Chrome and the server, and the server owner should be contacted about their HTTP/3/QUIC configuration.

Fix 5: Update Your Browser

Older Chrome versions (prior to version 100) lack support for some newer HTTP/2 server-side features. Keeping your browser current ensures full HTTP/2 compatibility:

• Chrome: Menu > Help > About Google Chrome — Chrome checks for updates automatically on this screen
• Firefox: Menu > Help > About Firefox
• Edge: Menu > Help and feedback > About Microsoft Edge

Fix 6: Disable Antivirus HTTPS Scanning

If you have antivirus software that inspects HTTPS connections, it may be breaking HTTP/2 by acting as a proxy that does not support HTTP/2’s binary framing protocol. Temporarily disable HTTPS scanning to test:

• Avast: Settings > Protection > Core Shields > Web Shield > turn off HTTPS scanning
• Kaspersky: Settings > Protection > Web Anti-Virus > HTTPS traffic scanning > disable
• Bitdefender: Settings > Protection > Online Threat Prevention > disable SSL scan
• ESET: Settings > Internet protection > Web access protection > TLS filtering > disable

If disabling HTTPS scanning resolves the error, check for an update to your antivirus software — newer versions of most products have improved HTTP/2 compatibility.

Fix 7: Try a Different Network

If none of the above fixes work, try accessing the site on a completely different network — use your mobile phone’s data connection as a hotspot, for example. If the site loads fine on mobile data but not on your regular network, the problem is network-level: a corporate firewall, ISP-level deep packet inspection, or a Wi-Fi router that interferes with HTTPS connections.

Fix 8: Check Your System Date and Time

HTTP/2 over HTTPS relies on TLS certificates which have validity periods checked against your system clock. If your device’s date or time is significantly wrong, TLS handshakes fail, which in turn causes HTTP/2 connection failures. Check that your system time is set to sync automatically with a time server:

• Windows: Right-click the clock > “Adjust date/time” > enable “Set time automatically”
• macOS: System Preferences > Date & Time > enable “Set date and time automatically”

Fix 9: Flush DNS Cache

Stale DNS records can occasionally contribute to connection issues. Flushing the DNS cache is a quick step with no downside:

• Windows (Command Prompt as Administrator): ipconfig /flushdns
• macOS (Terminal): sudo killall -HUP mDNSResponder

---

HTTP/2 Protocol Error in WordPress: Site Owner Fixes

If visitors to your WordPress site are seeing ERR_HTTP2_PROTOCOL_ERROR — or if you are seeing it when accessing your own site — the problem is likely on the server side. Here is how to diagnose and fix it without needing to be a server expert.

Step 1: Test Your SSL Certificate

The single most common server-side cause of HTTP/2 errors is an SSL certificate problem. Use the free SSL Labs test to check your certificate:

1. Go to https://www.ssllabs.com/ssltest/
2. Enter your domain name and click Analyse
3. Review the results — specifically look for: expired certificate, incomplete certificate chain, TLS 1.0 or 1.1 in use (modern browsers and HTTP/2 require TLS 1.2 or higher)

If your certificate has expired or shows chain issues, log into your hosting control panel (cPanel, Plesk, or your host’s dashboard) and renew or reinstall the SSL certificate. Most managed WordPress hosts handle this automatically — if yours does not, contact your hosting provider’s support team.

Step 2: Verify Your Host Supports HTTP/2

Not all hosting plans support HTTP/2. Budget shared hosting plans sometimes run older web server versions that do not have HTTP/2 enabled. To check:

• Use an online HTTP/2 test tool such as https://tools.keycdn.com/http2-test
• Enter your domain — the tool will report whether HTTP/2 is active

If HTTP/2 is not active, contact your hosting provider and ask them to enable it. On servers you control, the server-side fixes in the next section apply.

Step 3: Check Cloudflare SSL Settings

If your WordPress site uses Cloudflare (either as a CDN or for DNS), an incorrect SSL mode setting is one of the most common causes of protocol errors:

1. Log into your Cloudflare dashboard
2. Select your domain
3. Go to SSL/TLS > Overview
4. Ensure the SSL mode is set to Full (Strict) — not “Flexible” or “Off”
5. After changing the mode, go to Caching > Configuration and click Purge Everything

The “Flexible” mode encrypts the browser-to-Cloudflare connection but sends traffic to your origin server without SSL. This creates a protocol mismatch that often results in HTTP/2 errors.

Step 4: Deactivate Caching Plugins

WordPress caching plugins manage HTTP response headers, including cache-control and pragma headers. Some caching plugins or their minification features generate headers that violate HTTP/2 requirements. To test:

1. Log into your WordPress admin panel
2. Go to Plugins > Installed Plugins
3. Deactivate your caching plugin (WP Rocket, W3 Total Cache, WP Super Cache, LiteSpeed Cache)
4. Clear your browser cache and reload the page

If the error disappears, the caching plugin was the cause. Check for an update to the plugin first. If there is no update, check the plugin’s settings for HTTP/2 push or header optimisation options and disable them.

Step 5: Check for Plugin and Theme Conflicts

Any WordPress plugin that outputs HTTP headers or modifies the response pipeline could theoretically cause HTTP/2 issues. Security plugins (Wordfence, iThemes Security), page builder plugins, and theme framework plugins are all candidates.

To perform a conflict test:

1. Deactivate all plugins (except your caching plugin if you already tested that separately)
2. Test the site — if the error is gone, the problem is a plugin
3. Reactivate plugins one by one, testing after each, to identify the culprit
4. If all plugins are deactivated and the error persists, switch to a default WordPress theme (Twenty Twenty-Four) to test for a theme conflict

Step 6: Check for WooCommerce-Specific Issues

WooCommerce sites can trigger HTTP/2 errors specifically during checkout or when loading product pages with many assets. This is usually a header issue caused by WooCommerce’s session handling generating connection-specific HTTP headers (like Keep-Alive or Transfer-Encoding) that are forbidden in HTTP/2. Contact your hosting provider and ask them to verify that their HTTP/2 implementation correctly strips these headers before serving responses.

---

Server-Side HTTP/2 Fixes: Nginx and Apache

If you manage your own VPS, dedicated server, or cloud instance, the fixes below apply directly to your server configuration.

Enable HTTP/2 in Nginx

Nginx requires version 1.9.5 or higher and OpenSSL 1.0.2 or higher for HTTP/2 support. To enable it, add the http2 keyword to your HTTPS listen directive.

A correctly configured Nginx server block for HTTP/2 looks like this:

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name yourdomain.com www.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers off;

    # ... rest of your configuration
}

After editing, test and reload nginx:

sudo nginx -t
sudo systemctl reload nginx

To verify HTTP/2 is active, run:

curl -I --http2 https://yourdomain.com

You should see HTTP/2 200 in the response.

Fix the Nginx CSP Header Bug

There is a known nginx issue where a Content-Security-Policy header written across multiple lines in the nginx configuration file triggers HTTP/2 protocol errors. If you have a long CSP policy, ensure it is written on a single line:

# Wrong — may cause HTTP/2 errors
add_header Content-Security-Policy "default-src 'self';
    script-src 'self' https://cdn.example.com;
    style-src 'self'";

# Correct — single line
add_header Content-Security-Policy "default-src 'self'; script-src 'self' https://cdn.example.com; style-src 'self'";

Enable HTTP/2 in Apache

Apache requires version 2.4.17 or higher and the mod_http2 module. Enable it and configure your VirtualHost:

# Enable the module
sudo a2enmod http2

# In your SSL VirtualHost configuration
<VirtualHost *:443>
    ServerName yourdomain.com
    Protocols h2 http/1.1

    SSLEngine on
    SSLCertificateFile /etc/letsencrypt/live/yourdomain.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/yourdomain.com/privkey.pem

    # ... rest of your VirtualHost config
</VirtualHost>

Reload Apache after making changes:

sudo systemctl reload apache2

Fix an Incomplete SSL Certificate Chain

An incomplete certificate chain is a very common cause of HTTP/2 errors on self-managed servers. When using Let’s Encrypt with Certbot, always reference the fullchain.pem file in your server configuration — not cert.pem. The fullchain.pem file includes both your domain certificate and the intermediate certificates needed to verify it.

• Nginx: ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
• Apache: SSLCertificateFile /etc/letsencrypt/live/yourdomain.com/fullchain.pem

To test that your certificate chain is complete:

openssl s_client -connect yourdomain.com:443 -showcerts

The output should show multiple certificates in the chain. If you only see one certificate, the chain is incomplete.

Strip HTTP/2-Incompatible Headers from Upstream Responses

When nginx acts as a reverse proxy in front of an application server (Node.js, PHP-FPM, etc.), the upstream application may send HTTP headers that are incompatible with HTTP/2. Headers like Connection, Keep-Alive, and Transfer-Encoding are connection-specific headers that are forbidden in HTTP/2. Use proxy_hide_header to remove them:

location / {
    proxy_pass http://your_upstream;
    proxy_http_version 1.1;
    proxy_hide_header Connection;
    proxy_hide_header Keep-Alive;
    proxy_hide_header Transfer-Encoding;
}

---

HTTP/2 Protocol Errors from Firewalls and Security Appliances

If users on a specific corporate network or school network are seeing ERR_HTTP2_PROTOCOL_ERROR while users on home or mobile connections can access the same site without problems, a firewall is almost certainly the cause.

Most enterprise firewalls perform SSL inspection — they intercept HTTPS connections, decrypt them, inspect the traffic, then re-encrypt and forward. This process involves stripping the ALPN header, which is the mechanism that browsers and servers use to agree on using HTTP/2. When the ALPN header is stripped, the server defaults to HTTP/1.1 — but if the browser and server have already partially negotiated HTTP/2, the mismatch causes a protocol error.

For network administrators:

• Palo Alto Networks: Check the SSL Decryption policy for the “Strip ALPN” option; also verify that the PAN-OS trust store includes current Let’s Encrypt intermediate certificates (the DST Root CA X3 cross-sign has expired and caused widespread errors on older PAN-OS versions)
• General firewalls: Add affected domains to the SSL inspection exclusion list, or ensure the firewall’s SSL inspection engine is updated to support HTTP/2 ALPN forwarding
• Corporate proxy servers: Verify that the proxy correctly forwards ALPN extensions and does not degrade HTTP/2 connections to HTTP/1.1 without informing the client

For users on restricted networks: If you cannot change the firewall settings, the only reliable workaround is to connect through a VPN that tunnels your traffic outside the network’s inspection perimeter, or to use mobile data for affected sites.

---

HTTP/2 Protocol Error: Quick Reference by Browser Message

Different browsers and configurations produce slightly different error messages for the same underlying HTTP/2 problem. Use this table to identify your error and the most likely first fix:

Error Message	Browser	Most Likely Cause	First Fix
ERR_HTTP2_PROTOCOL_ERROR	Chrome / Edge	Cache, extension, or server config issue	Clear cache + disable extensions
ERR_HTTP2_INADEQUATE_TRANSPORT_SECURITY	Chrome / Edge	TLS 1.0 or 1.1 in use on the server	Enable TLS 1.2+ on server
NS_ERROR_NET_INADEQUATE_SECURITY	Firefox	TLS version or cipher suite incompatibility	Check SSL cert + TLS config
The connection was reset	Firefox	Server-side HTTP/2 error or extension conflict	Hard refresh + check server logs
GOAWAY frame received	Any (in logs)	Server gracefully shutting down HTTP/2 stream	Check server logs + restart
Failed to load resource: net::ERR_HTTP2_PROTOCOL_ERROR	Chrome (DevTools console)	Specific resource (JS/CSS/image) failing over HTTP/2	Check resource URL, clear cache, check CDN config

The last entry — “Failed to load resource: net::ERR_HTTP2_PROTOCOL_ERROR” in the browser’s developer console — is a WordPress-specific variant that often appears when a plugin or theme asset (a CSS file, JavaScript file, or image) fails to load. It does not always mean the entire site is down; only that specific resource is failing. Open Chrome DevTools (F12), go to the Network tab, reload the page, and identify which resource is throwing the error. The URL of that resource tells you whether it is loading from your server, a plugin’s CDN, or a third-party service.

---

Frequently Asked Questions About HTTP/2 Protocol Errors

What does ERR_HTTP2_PROTOCOL_ERROR mean?

ERR_HTTP2_PROTOCOL_ERROR is a Chrome browser error that appears when the HTTP/2 communication between your browser and a web server breaks down. HTTP/2 is the modern protocol used to transfer web pages. When the rules of this protocol are violated — due to corrupted cache data, a server misconfiguration, a broken SSL certificate, or network interference — Chrome blocks the connection and shows this error instead of loading the page.

Is ERR_HTTP2_PROTOCOL_ERROR a problem with my browser or the website?

It can be either. If you see the error on only one website but other sites load fine, the problem is most likely on that website’s server. If you see the error on multiple websites, the problem is almost certainly on your side — a corrupted browser cache, a browser extension conflict, or security software interfering with your connections. Testing in incognito mode without extensions is the fastest way to determine which side the problem is on.

Why am I getting ERR_HTTP2_PROTOCOL_ERROR on only one website?

When the error occurs on a single site, the cause is usually on that site’s server. Common site-specific causes include an expired or misconfigured SSL certificate, an incorrect Cloudflare SSL mode setting, a server that has HTTP/2 partially enabled or incorrectly configured, or a recent server change that broke the HTTP/2 handshake. You can verify this by testing the site from a different device or network — if others can access it fine, contact the site owner or your hosting provider.

Can Cloudflare cause HTTP/2 protocol errors?

Yes. The most common Cloudflare-related cause is having the SSL mode set to “Flexible” instead of “Full (Strict).” In Flexible mode, Cloudflare accepts HTTPS from your browser but uses HTTP (unencrypted) to connect to your origin server. This creates a protocol mismatch that can cause HTTP/2 failures. The fix is straightforward: in your Cloudflare dashboard, navigate to SSL/TLS > Overview and change the SSL mode to Full (Strict), then purge the Cloudflare cache.

How do I fix HTTP/2 protocol error in Chrome?

Start with the four most effective fixes: (1) Clear your browser cache via Settings > Privacy and Security > Clear browsing data; (2) Open the page in incognito mode to rule out extension conflicts; (3) Navigate to chrome://flags and disable the “Experimental QUIC protocol”; (4) Flush Chrome’s socket pool via chrome://net-internals/#sockets. If none of these work, disable your antivirus’s HTTPS scanning feature and test again. For persistent issues affecting a specific site, the problem is server-side and you or the site owner need to check the SSL certificate and server HTTP/2 configuration.

Does disabling HTTP/2 fix ERR_HTTP2_PROTOCOL_ERROR?

It can work as a temporary workaround. You can force Chrome to use HTTP/1.1 by disabling HTTP/2 in Chrome’s flags, or the site owner can temporarily disable HTTP/2 on their server. However, this is not a real fix — HTTP/2 is significantly faster than HTTP/1.1 and you will notice a performance degradation. The correct approach is to identify and fix the underlying cause rather than permanently downgrading the protocol.

Can antivirus software cause ERR_HTTP2_PROTOCOL_ERROR?

Yes, and this is more common than most people realise. Antivirus programs that include HTTPS inspection (sometimes called “Web Shield” or “SSL scanning”) act as a man-in-the-middle proxy between your browser and websites. Many antivirus HTTPS inspection engines were built before HTTP/2 became universal and do not fully support HTTP/2’s binary framing. The result is a broken HTTP/2 connection. Avast, Kaspersky, Bitdefender, and ESET are the most commonly reported culprits. Temporarily disabling HTTPS scanning in your antivirus settings is the fastest diagnostic test.

Why does my WordPress site show HTTP/2 protocol errors to visitors?

WordPress sites show HTTP/2 protocol errors to visitors for several reasons: an expired or incorrectly installed SSL certificate is the most common cause. Other causes include Cloudflare SSL mode set to “Flexible,” a caching plugin generating HTTP/2-incompatible response headers, or the hosting server not having HTTP/2 properly enabled. For WooCommerce sites, connection-specific HTTP headers generated during checkout sessions can also cause this error. Start by running an SSL Labs test on your domain to check certificate health, then check your Cloudflare settings if applicable.

What is the difference between HTTP/2 and HTTP/3?

HTTP/2 uses TCP (Transmission Control Protocol) as its transport layer and multiplexes multiple streams over a single TCP connection. HTTP/3 is the newer standard that uses QUIC — a protocol built on UDP — as its transport layer. QUIC was designed to avoid the “head-of-line blocking” problem that affects TCP when a single packet is lost. Chrome implements QUIC under the label “Experimental QUIC protocol” in its flags. When QUIC fails to negotiate properly with a server, it can fall back to HTTP/2, but if that fallback is misconfigured, an ERR_HTTP2_PROTOCOL_ERROR can result. As of 2026, approximately 8% of websites actively support HTTP/3/QUIC.

How can I check if my server supports HTTP/2?

There are three easy ways. First, use an online tool: KeyCDN’s HTTP/2 Test at https://tools.keycdn.com/http2-test will test your domain and report whether HTTP/2 is active. Second, use curl from a command line: curl -I --http2 https://yourdomain.com — a response showing HTTP/2 200 confirms HTTP/2 is working. Third, in Chrome DevTools: open the Network tab (F12), load your site, right-click any request, choose “More columns,” and add the “Protocol” column — you will see “h2” for HTTP/2 requests or “http/1.1” for HTTP/1.1.

---

Summary

HTTP/2 protocol errors look serious but almost always have a fixable cause. For most people visiting a website that suddenly shows ERR_HTTP2_PROTOCOL_ERROR, the solution is one of the basics: clear the browser cache and flush the socket pool in Chrome, open the page in incognito mode to rule out extensions, or disable the QUIC protocol flag. These three steps resolve the majority of cases.

For WordPress site owners, the most important checks are: verify your SSL certificate is valid and complete using SSL Labs, confirm Cloudflare is set to Full (Strict) SSL mode if you use it, and test whether your caching plugin is generating problematic headers.

For server administrators managing nginx or Apache, enable HTTP/2 in the server configuration, ensure you are using the full certificate chain file, and watch out for the nginx CSP header multi-line bug.

If none of these fixes apply and the error persists on a specific network, a firewall performing SSL inspection and stripping ALPN headers is the most likely culprit — one for your network administrator to investigate.

Work through the fixes systematically and the error will resolve. HTTP/2 is a well-supported, stable protocol — when it breaks, it breaks in predictable ways that have well-known solutions.