505 HTTP Version Not Supported 5xx

What does 505 mean?

A 505 HTTP Version Not Supported response means the server doesn't support (or refuses to support) the version of the HTTP protocol used in the request — for example, a client using HTTP/1.0 making a request to a server that only supports HTTP/1.1 and above, or vice versa, an unusually old server encountering a request formatted for a newer protocol version it doesn't understand.

This is one of the rarest status codes in practical use today. HTTP/1.1 has been the baseline for the vast majority of the web for decades, and modern protocol versions (HTTP/2, HTTP/3) are typically negotiated transparently — clients and servers agree on a mutually-supported version without the client ever sending a request in a version the server flatly rejects.

How a 505 behaves

• It can carry a body explaining the version mismatch, often including which versions the server does support
• It's not cacheable — represents a fundamental protocol-level incompatibility for this specific connection
• It typically indicates either very old client/server software, or a deliberate testing/research scenario — genuine 505s in production traffic between modern, well-maintained systems are extremely uncommon

Common causes

If you're building/operating the server:

• Your server has deliberately dropped support for an old HTTP version (e.g., HTTP/1.0) for security or maintenance reasons, and an old client is still using it
• A misconfiguration causes a version mismatch that wouldn't normally occur with standard clients

If you're calling an API:

• You're using an extremely old HTTP client library that defaults to an outdated protocol version no longer supported by modern servers
• You're deliberately testing protocol-version handling (e.g., security testing, protocol compliance testing) by sending requests with unusual version declarations

If you're a website visitor:

• Essentially never — modern browsers negotiate HTTP versions transparently and would not present a user with a 505 under normal circumstances

How to fix it

As an API/website builder:

• If 505 is appearing for legitimate traffic, this likely indicates very outdated client software is still in use — consider whether you need to maintain backward compatibility with that old version, or whether it's acceptable for those clients to fail
• Ensure your server's supported HTTP version range is documented if you've deliberately dropped support for older versions

As an API consumer:

• Update your HTTP client library — extremely outdated libraries might default to or only support HTTP versions that modern servers no longer accept
• If working with very old/legacy server software from the other direction, you may need to use a client capable of HTTP/1.0 (or whatever version that old server expects)

As a website visitor:

• Not applicable — update your browser if somehow using one old enough for this to be relevant, though this would be an extraordinarily unusual scenario

505 vs 501

Real-world examples

505 is genuinely difficult to encounter in normal modern usage — HTTP/1.1 compatibility is essentially universal, and HTTP/2/3 negotiation happens transparently at the connection level (via mechanisms like ALPN during TLS handshakes) without typically resulting in a client sending a request in a version the server outright rejects. Security researchers and protocol-compliance test suites sometimes deliberately construct requests with unusual or malformed version declarations specifically to verify a server's 505 handling, which is one of the few contexts where this code is intentionally triggered.

SEO implications

None of practical relevance — search engine crawlers use well-supported HTTP versions, making 505 essentially irrelevant to crawling/indexing in any normal scenario.

FAQ

Is 505 something I'm likely to ever see?

Very unlikely in normal development or browsing. It's one of the rarest status codes in practical use, mostly relevant to extremely old software, deliberate protocol testing, or unusual edge cases in version negotiation.

How does HTTP version negotiation normally work?

For HTTP/2 and HTTP/3, negotiation typically happens during the TLS handshake (via ALPN), allowing client and server to agree on a mutually-supported version before any HTTP request is even sent — avoiding scenarios where a request is sent in an unsupported version and rejected with 505.

What HTTP versions are most servers expected to support?

HTTP/1.1 remains a near-universal baseline, with most modern servers also supporting HTTP/2 and increasingly HTTP/3 — but dropping HTTP/1.1 support entirely would be unusual given how foundational it remains, even as newer versions are layered on top.

Could 505 ever occur with a perfectly normal browser?

Practically never — modern browsers and modern servers operate within a well-supported, overlapping range of HTTP versions, and version negotiation mechanisms are specifically designed to avoid sending requests in versions that would be rejected.

Is 505 related to HTTPS/TLS version issues?

Not directly — TLS version mismatches (e.g., a client requiring TLS 1.3 against a server only supporting TLS 1.2) would typically prevent the connection from being established at all (a connection-level/TLS-level failure), occurring before any HTTP request/response — distinct from 505, which is an HTTP-level response indicating the HTTP protocol version (not the TLS version) isn't supported.

Fun fact

505 might be the status code most likely to be encountered only in the context of someone deliberately testing how a server handles unusual inputs — in a sense, its rarity in "organic" traffic makes its presence in logs almost a signal in itself: if you're seeing 505s, it's worth considering whether they represent deliberate probing/testing rather than genuine client compatibility issues.