OCSP stapling is a TLS optimization that lets your web server fetch a signed proof that its certificate has not been revoked, cache it, and hand it to every visitor during the handshake. Without stapling, each browser has to contact the certificate authority itself to ask whether the certificate is still good, which is slow, leaks the sites you visit to the CA, and often fails silently. This guide explains what problem stapling solves, how the stapled response travels inside the TLS handshake, how it compares to plain OCSP, what the Must-Staple flag commits you to, and how to turn stapling on and confirm it is actually working.
What OCSP stapling solves
The Online Certificate Status Protocol, defined in RFC 6960, lets a client ask a CA whether a specific certificate has been revoked before its expiry date. In the original design the browser makes that query itself, reaching out to the CA responder named in the certificate every time it meets a new site. That creates three problems. It is slow, because the browser pauses the connection to make a separate request to a server it does not control. It is a privacy leak, because the CA learns which sites each user visits and when. And it is unreliable, because if the responder is slow or unreachable most browsers simply carry on without an answer, a behavior known as soft-fail that quietly defeats the whole check.
Stapling moves the work to the server. Your server queries the CA responder on a schedule, receives a short-lived signed status response, and caches it. When a visitor connects, the server attaches, or staples, that response to the certificate it sends. The browser gets its revocation proof in the same round trip as the certificate, with no second connection and nothing disclosed to the CA.
How the stapled response rides in the handshake
Stapling uses the TLS Certificate Status Request extension described in RFC 6066. The client advertises that it supports status requests in its ClientHello. The server, if it has a cached OCSP response, includes that response in its half of the handshake alongside the certificate. The response is itself signed by the CA, so the browser can verify it independently; a malicious server cannot forge a clean status. Because the response carries its own validity window, usually a few days, the server refreshes it well before it expires and keeps serving the cached copy in between.
One limitation of the basic extension is that it staples a status only for the leaf certificate, not for the intermediates in the chain. A later extension, Multiple Certificate Status Request, can cover more of the chain, but support for it is uneven, so in practice stapling is a leaf-certificate mechanism.
Stapling versus plain OCSP
The table below compares the two ways a client can learn a certificate's revocation status.
| Property | Plain OCSP (client queries) | OCSP stapling (server staples) |
|---|---|---|
| Who contacts the CA | Every visitor's browser | Your server, on a schedule |
| Handshake speed | Extra round trip to the CA | No extra round trip |
| Privacy | CA sees each visitor's browsing | CA sees only your server |
| If the responder is down | Browser soft-fails, check skipped | Server serves the cached response |
| Who signs the status | The CA | The CA (server only relays it) |
Must-Staple: closing the soft-fail gap
Stapling improves speed and privacy, but on its own it does not force anything: if the server omits the stapled response, browsers fall back to soft-fail and connect anyway. The TLS Feature extension in RFC 7633, commonly called OCSP Must-Staple, closes that gap. When a certificate is issued with the Must-Staple flag set, a conforming browser will refuse the connection if a valid stapled response is not present. That turns a best-effort optimization into a hard requirement.
Must-Staple is powerful and risky in equal measure. If your stapling setup breaks, perhaps the server cannot reach the responder and its cache expires, every visitor is hard-blocked rather than quietly allowed through. Only enable Must-Staple once you have confirmed your server fetches and refreshes responses reliably, and keep monitoring it. The flag is baked into the certificate at issuance, so you cannot remove it without reissuing.
How to enable and verify stapling
- Confirm your web server supports stapling. Nginx uses ssl_stapling on with a resolver directive; Apache uses SSLUseStapling on with a configured SSLStaplingCache.
- Give the server a working outbound path and a DNS resolver so it can reach the CA responder named in your certificate.
- Reload the server and make the first few connections, which prime the cache; the very first request after a reload may go out without a staple.
- Verify from the command line with openssl s_client -connect example.com:443 -status and look for the OCSP Response Data block in the output.
- Check the Next Update field in that response and make sure the server refreshes before it passes, so the cache never serves a stale or empty status.
- Only after stapling is proven stable should you consider requesting a Must-Staple certificate.
You can also confirm the certificate and its status fields from a live external check with the Valla DNS SSL checker, which reads what your server actually presents rather than what your config file claims.
Where OCSP stands as of November 2026
The revocation landscape is shifting. As of November 2026, some certificate authorities, including Let's Encrypt, have stopped operating OCSP responders and now rely on short certificate lifetimes and Certificate Revocation Lists instead. For certificates from those CAs there is no OCSP response to staple, and stapling simply has no effect. For CAs that still run responders, stapling remains the right default because it is faster and more private than client-side queries. The practical takeaway is to check whether your CA still provides OCSP at all, and if it does, staple it; if it does not, lean on automated short-lifetime renewal, which you should be doing regardless. Reading your issuer field is the quickest way to know which camp you are in, as covered in our guide on how to check an SSL certificate issuer, chain, expiry, and SAN.
Frequently asked questions
Does OCSP stapling make my site faster for everyone?
It removes the extra round trip a browser would otherwise make to the CA, so it speeds up the handshake for clients that would have performed a live OCSP check. Clients that cache status or skip the check anyway see little change, but stapling never makes the handshake slower.
Is stapling a privacy feature or a performance feature?
Both. It saves a round trip, and it stops the CA from learning which sites each of your visitors loads, because only your server talks to the responder. The privacy gain is often the more meaningful of the two.
What happens if my server cannot reach the OCSP responder?
If the certificate is not Must-Staple, the server sends no staple and browsers soft-fail, connecting without a fresh status. If the certificate is Must-Staple, browsers refuse the connection, so a broken responder path becomes an outage. Monitor the Next Update field to avoid this.
Do I still need stapling if my CA has dropped OCSP?
No. If the CA no longer runs a responder there is nothing to staple, and that CA relies on short lifetimes and revocation lists instead. Keep automated renewal tight and move on; stapling config for that certificate has no effect.
Does stapling cover the whole certificate chain?
The common extension staples a status for the leaf certificate only. A separate Multiple Certificate Status extension can cover intermediates, but client and server support is inconsistent, so most deployments staple the leaf and leave intermediate status to other mechanisms.
OCSP stapling is one of the cheaper wins in TLS: a small server setting that speeds up connections and protects your visitors' privacy at once. Confirm your certificate and what your server presents with a live run on the SSL checker before you decide whether Must-Staple is worth the added strictness.