TLS 1.2 and TLS 1.3 both protect application traffic, but they organize negotiation differently. TLS 1.3 removes older cryptographic choices, changes the handshake, and adds an optional way to send early data on a resumed connection. TLS 1.2 remains useful for clients that do not support TLS 1.3, provided TLS 1.2 is configured with suitable algorithms and security extensions. The choice depends on the clients you need to support and the settings available on each endpoint.

The client and server negotiate a mutually supported TLS version for each connection. A browser, proxy, application library, and origin server may each support different versions. A site behind a CDN can use TLS 1.3 toward visitors while the edge uses TLS 1.2 toward the origin. Inspect the relevant connection before drawing conclusions from a version shown in one browser.

Compare Negotiation and Cipher Choices

In TLS 1.2, a cipher suite can combine key exchange, authentication, encryption, and integrity choices. The protocol supports older options, so operators need to configure the permitted suites and protocol extensions carefully. For example, authenticated encryption protects both confidentiality and integrity, while ephemeral key exchange uses temporary keys to help protect past sessions if a long-term private key is later stolen. The chosen algorithms and settings matter as well as the TLS version.

TLS 1.3 requires authenticated encryption with associated data, or AEAD, for record protection. It also separates authentication and key exchange from the cipher suite used to protect traffic. Static RSA and static Diffie-Hellman key exchange are no longer allowed. In a full certificate-based TLS 1.3 handshake, fresh key exchange provides forward secrecy: obtaining the server's long-term private key later does not, by itself, allow someone to decrypt previously recorded sessions. A connection using only a pre-shared key does not provide the same protection against later compromise of that key.

For HTTPS, both versions still require a valid server identity check. TLS 1.3 does not make an expired, mismatched, or untrusted certificate acceptable. It also does not automatically hide every handshake detail. Server Name Indication (SNI) normally exposes the requested hostname in the ClientHello message; TLS 1.3 alone does not encrypt that part of the exchange.

Understand the Handshake Difference

A typical full TLS 1.2 handshake takes two round trips before the client can send application data. TLS 1.3 usually reduces that exchange to one round trip by sending key exchange information earlier. A TLS 1.3 server can request different key exchange parameters with a HelloRetryRequest, which adds a round trip. These counts concern the TLS handshake itself, not DNS resolution or the underlying transport connection, and they do not guarantee a fixed improvement in page load time.

Page load time also includes DNS resolution, transport establishment, proxy delays, and application work. Saving a handshake round trip has a greater effect when network latency is high. Session resumption and already-open connections change the comparison again. Measure connection and response times for the clients and servers you actually use if performance is the reason for a configuration change. Do not assume that enabling TLS 1.3 between visitors and a CDN also changes the independent connection between the CDN and the origin.

TLS 1.3 uses a revised version negotiation mechanism. When both peers support it and policy permits it, they can negotiate TLS 1.3. If one side only supports TLS 1.2, a compatible connection can still use TLS 1.2 under a secure configuration. A handshake error can result from policy or implementation mismatch, so record the offered and selected versions rather than guessing from a browser message.

Treat Zero-RTT Early Data as Optional

TLS 1.3 can allow a client to send application data with its first handshake message, commonly called zero-RTT or early data. Early data requires a suitable pre-shared key, usually established during an earlier connection, although a key can also be provisioned separately in a controlled deployment. The server can reject early data and continue the handshake without accepting those requests. Unlike ordinary traffic protected by fresh key exchange, early data does not have a protocol guarantee of forward secrecy.

Zero-RTT data can be replayed. An attacker able to duplicate early data may cause an application action to run more than once unless the application and server are designed to prevent it. Requests that change state, charge money, or perform one-time actions should not be accepted merely because early data is encrypted. Operators should use the application protocol's replay guidance and keep early data disabled for actions that are not safe to repeat. Enabling TLS 1.3 does not automatically enable early data.

Check Client Compatibility

Modern browsers commonly support TLS 1.3, but older devices, libraries, embedded clients, and enterprise intermediaries may differ. Support securely configured TLS 1.2 when required by your clients, and prefer TLS 1.3 when available. TLS 1.0 and TLS 1.1 should no longer be negotiated. Disabling TLS 1.2 without checking client support can prevent otherwise compatible clients from connecting; retaining obsolete SSL or older TLS versions does not solve that problem safely.

Check the clients you need to support and any intermediary before changing policy. A reverse proxy or load balancer may have its own protocol support and certificate settings. Public websites and private APIs may serve different clients, so assess compatibility separately for each service. Keep software and TLS libraries current so that supported versions and security fixes are available.

Check the Negotiated Version

Inspect the negotiated version and cipher on the intended public endpoint and, where relevant, on the origin connection. Confirm that the selected certificate names and chain are correct in both cases. Test representative authorized clients and inspect server logs for version or handshake failures after a change. If early data is enabled, verify that requests that are unsafe to repeat are rejected or handled with the application protocol's required replay safeguards.