SSL Certificate Expiry: Every Stage From Warning to Failure
Key takeaways
- When an SSL certificate's notAfter timestamp passes, every validating client rejects the TLS handshake; the server itself keeps running normally.
- Browsers show a clickable interstitial at expiry, but API clients, mobile apps, and webhook receivers hard-fail with no bypass option.
- Fix an expired certificate by issuing the replacement first, then deploying the fullchain and key to every TLS termination point and reloading rather than restarting.
- Verify a renewal by running openssl s_client against every public endpoint and confirming all load balancer nodes serve the same future notAfter date.
- Alert at 30, 14, 7, and 3 days before expiry so broken renewal automation is caught while there is still slack.
SSL certificate expiry doesn't happen all at once. Browsers start warning users around 30 days out, API clients and mobile apps fail differently than browsers, and webhooks often break silently before anyone notices. This guide walks through each stage of expiry and what to do before and after the deadline hits.
What happens when an SSL certificate expires?
An SSL certificate carries two timestamps: notBefore and notAfter. When the notAfter timestamp passes, the validity window closes and the certificate is technically expired. Nothing changes on your server at that moment, but every client that validates the certificate chain rejects the TLS handshake and refuses to connect.
The rejection behaviour is not optional. Browsers, API clients, and mobile SDKs follow the CA/Browser Forum baseline requirements, which define certificate validity periods and require clients to check them (CA/Browser Forum Baseline Requirements). A curl call fails, a webhook endpoint stops accepting deliveries, and your app shows a certificate error instead of your product.
Because the failure is at the protocol level, a URL check that returns 200 from a non-validating client will not catch it. Protocol-level probes that validate the full chain, like StatusPulse's SSL monitoring, flag the expiry window before the handshake starts failing.
How long before expiry do browsers start warning users?
For almost the entire certificate lifetime, browsers stay silent. There is no countdown banner at 30 days, 14 days, or 7 days. The first user-facing signal appears the moment the notAfter timestamp passes, and it is not a warning you can click through casually.
What the browser interstitial actually blocks
At expiry, Chrome, Firefox, and Safari all replace your page with a full-screen interstitial (ERR_CERT_DATE_INVALID in Chrome). Users can click "Advanced" and proceed, but anything loaded over that connection, including your app shell, XHR calls, and login flows, fails or behaves unpredictably. API clients and mobile apps have no "proceed anyway" button at all, which is why the browser warning is only the visible edge of the problem (Expired SSL Certificate Risks for Security and Website Access).
Why some browsers warn earlier than others
They don't, in the user-facing sense. All three major engines enforce the same expiry timestamp with the same hard cut. Differences are cosmetic: Chrome's interstitial is more aggressive about discouraging bypass, Firefox offers clearer "accept the risk" wording, and Safari's override is buried behind a "Show Details" flow. What varies earlier is your monitoring and CA renewal emails, not the browser.
Does an expired SSL certificate break API clients and mobile apps, not just browsers?
Browsers show a warning page you can click through. API clients, mobile apps, and CLI tools do not: they hard-fail the TLS handshake the moment the certificate chain fails validation. There is no interstitial, no "proceed anyway" button, and no partial response. Your browser-based status page can look fine while every programmatic client is getting connection errors.
Browsers tolerate expiry with a warning because they assume a human is watching. Chrome and Firefox show a full-page SSL error interstitial that users can bypass. Machines make no such assumption, and certificate validation libraries throw immediately.
Mobile apps: pinned certificates and store-update lag
Mobile clients fail hardest. Many apps pin certificates or validate strictly, so an expired cert means the app simply cannot reach your API. Even after you renew, users on old app versions may stay broken until they update, and App Store review cycles add days.
Webhooks and outbound API calls fail silently
Outbound calls fail with less noise. A webhook receiver rejecting your expired cert looks identical to a timeout in most logs, so retries pile up while the receiving side never learns why. This is exactly the gap protocol-level probes catch that URL checks miss.
CLI tools, SDKs, and server-to-server TLS
| Client type | Behaviour at expiry | User sees |
|---|---|---|
| Browser | Interstitial, clickable | Warning page |
| Mobile app (pinned) | Hard handshake failure | App offline |
| Webhook receiver | Rejects, often silent | Missing events |
| CLI / SDK | TLS exception, no retry hint | Stack trace |
Server-to-server TLS between your own services fails the same way, so an expired internal cert can take down a deployment pipeline before customers notice. Plan alerts around the 30/14/7/1-day windows rather than expiry day: the four-alert strategy covers that cadence.
Can you still serve traffic with an expired certificate, and should you?
Yes, your server keeps serving. TLS termination still works, your app still responds, and load balancers rarely stop forwarding traffic over an expired cert. The failure happens on the client side: the handshake completes, the client validates the certificate, and then it rejects the connection.
That rejection is not uniform. Browsers show a full-page warning that some users will click through. API clients, mobile apps, and webhook receivers will not. Most HTTP libraries fail closed on certificate validation errors, so an expired cert means hard connection failures for every integration, cron job, and third-party consumer hitting your API, even while your homepage loads fine for you in a browser.
The emergency trade-off is ugly. Serving with an expired cert buys you minutes of browser traffic at the cost of broken API contracts and a public incident. The faster path is issuing a replacement certificate and deploying it, which takes minutes with Let's Encrypt or your CA of choice. If you want the failure caught before a customer notices, protocol-level probes that check certificate validity, not just HTTP 200s, are the point; we cover the checklist in our certificate expiry monitoring guide.
How do you fix an expired ssl certificate step by step?
Issue the replacement first, before touching anything running. With Let's Encrypt that is one certbot renew (or certbot certonly for a specific domain); with a paid CA, generate a fresh CSR and complete validation. Do not deploy until you hold the new fullchain and key files.
Deploying to load balancers vs the origin server Map every termination point before you deploy: your CDN, your load balancer, and any server terminating TLS directly. An expired certificate on the load balancer takes down the whole domain, but an expired cert on the origin behind a CDN can still break webhooks and API clients that connect directly. Install the new fullchain and private key at each point, then reload rather than restart where the software supports it: nginx -s reload and systemctl reload nginx drop no connections, while a full restart briefly does. If your monitoring is URL-only, it will show green the moment the page loads again even if a termination point is still broken, which is exactly the gap protocol-level probes catch (see our guide on preventing ssl certificate outages). Do this mapping before an expiry, not during one, because discovering a second termination point mid-incident is how outages stretch from minutes to hours. Incomplete chains: the second most common failure
A cert without its intermediate chain works in some browsers and fails in curl, mobile apps, and Java clients, because browsers cache intermediates and most API clients do not. Verify from the server side, not a browser: run openssl s_client -connect yourdomain.com:443 -servername yourdomain.com and confirm the presented chain reaches a trusted root, and use openssl verify against your fullchain file per the OpenSSL documentation. Fix by serving the fullchain file, not the bare certificate, at every termination point.
How do you verify a renewal actually deployed before the old cert expires?
Deploying a renewed certificate is not the same as serving it. Load balancers cache old certs, one node can miss the redeploy, and a managed renewer can fail silently. Verify the served leaf, not your config files.
Run this against every public endpoint, not just the apex:
openssl s_client -connect api.example.com:443 -servername api.example.com 2>/dev/null | openssl x509 -noout -enddate -subject
Check three things: the notAfter date is in the future, the subject CN or SAN matches the hostname, and every node behind your load balancer returns the same result. Repeat for each hostname, including wildcard subdomains and any webhook or API endpoints customers call.
Then test from outside your network. A VPN, office firewall, or same-region server can mask a broken deploy. A probe from a different network catches what your internal curl misses. Run the check once right after deploy and again an hour later, in case a reload job swaps certs on a delay.
How do you monitor certificate expiry across many domains?
Three approaches work for multi-domain teams. A cron job running openssl s_client -servername domain -connect domain:443 | openssl x509 -noout -enddate per domain is free and precise, but you own the alerting, the deduplication, and the cron host itself. Uptime monitors with SSL probes handle the scheduling and alerting for you, and most paid tiers include certificate checks. If you already run StatusPulse probes on each domain, the SSL check rides along with the uptime probe at no extra cost.
What a good SSL probe checks beyond the expiry date
Expiry is the obvious failure, but not the only one. A useful probe also verifies the full chain (a missing intermediate cert passes openssl x509 locally yet breaks mobile clients), the hostname match on the SAN list, and that the served cert is the one you expect, not a CDN default. Let's Encrypt issues 90-day certificates and expects renewal automation (Let's Encrypt documentation), so a cert that hasn't renewed on schedule is often a broken deploy hook, not a calendar problem.
Alert thresholds that avoid false alarms
Alert at 30 days for a ticket, 14 days for a warning, and 7 and 3 days for on-call pages. The 30-day alert catches broken automation while there's slack; the 3-day page is the one that wakes someone up. Anything earlier than 30 days produces alerts you learn to ignore, which defeats the point.
What does an expired ssl certificate cost your SaaS in customer trust?
An expired certificate doesn't degrade gracefully. API clients throw TLS errors, mobile apps fail on launch, and webhooks silently drop. Every paying customer hits a hard failure at the same minute, and none of them can tell the difference between a cert lapse and your product being down.
Support load spikes while you renew. Your status page still reads "all systems operational" if your monitoring is a URL check, because a URL check often passes on a redirect or cached response. Protocol-level probes catch the TLS handshake failing, and expiry warnings at 30 days mean you fix it before anyone opens a ticket.
That gap, between what your status page says and what customers see, is what they remember at renewal time.
FAQ
Will an expired SSL certificate slow my site down or does it just show an error?
It shows an error, not a slowdown. Once the notAfter timestamp passes, clients reject the TLS handshake entirely, so browsers display a full-page interstitial and API clients fail to connect at all. There is no degraded or slower mode in between: the connection either validates or it is refused before any of your code runs.
Do email servers and SMTP TLS also fail when a certificate expires?
Yes. SMTP servers that enforce TLS, especially those using STARTTLS with strict validation, will reject connections or refuse to deliver mail when the certificate chain fails validation. Like API clients, mail servers make no allowance for human oversight. Because delivery failures often surface only in mail server logs, an expired mail certificate can silently drop inbound messages from stricter sending domains.
How long does it take for a renewed certificate to propagate to all clients?
There is no propagation delay for the certificate itself: once you deploy the new fullchain and key at every termination point and reload, new handshakes use it immediately. What causes lag is your infrastructure, not the internet. Load balancers can cache old certs, individual nodes can miss the redeploy, and mobile apps with pinned certificates stay broken until users update.
Can I get an SSL certificate for free, and are free certs safe for production SaaS?
Yes, and yes. Let's Encrypt issues free 90-day certificates trusted by all major browsers and clients, and it expects you to automate renewal. Free certs are fine for production SaaS as long as renewal automation works and you monitor the expiry window, since a broken deploy hook or cron job is the real risk, not the certificate itself.