# Certificate Expiry and Lifetime Checker

Check the TLS certificate served by up to 21 hosts (domain plus hosts, host or host:port): issuer, issue and expiry dates, lifetime, days left and age, and whether each is trusted and matches its name. mode expiry sorts by days left; mode readiness judges each host against the 200 day cap now and the 100 day (2027-03-15) and 47 day (2029-03-15) caps, using Certificate Transparency renewal history when useCtHistory is on, and says whether renewal looks automated. Adds CAA, DNS-01 CNAME and domain registration expiry when known, and a calendar feed address. Returns a verdict (ready, action_needed, not_ready, unknown) and the limits with dates. Hosts must be public; at most 20 hosts per call.

**Not for:** Reading one certificate in depth (use ssl_check) or a certificate you paste (use x509_decode).

- Tool id: `cert-expiry-check`
- Category: security
- Execution: fanout
- MCP tool `cert_expiry_check` at https://lookupowl.com/mcp
- REST `GET https://lookupowl.com/api/v1/tools/cert-expiry-check` (or POST a JSON body)
- OpenAPI: https://lookupowl.com/api/openapi.json

## Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `domain` | string | yes |  | The first host to check, such as example.com (row one of the answer). A host:port is allowed. min length 1, max length 253 |
| `hosts` | string[] | no |  | Up to 20 more hosts, as host or host:port. Hosts past the 20th are listed as not checked. Wildcards such as *.example.com are not hosts: list the real names. max 60 items |
| `mode` | "expiry" \| "readiness" | no | `"expiry"` | expiry: days left, soonest first. readiness: the verdict against the shorter lifetimes coming in 2027 and 2029. |
| `useCtHistory` | boolean | no | `true` | Use Certificate Transparency logs for renewal history (readiness only). Without it only the certificate being served now is judged. |
| `includeDomainExpiry` | boolean | no | `true` | Add each registered domain's own expiry date, when the registry says it. |
| `warnDays` | integer | no | `21` | Days left at or below which a certificate counts as expiring soon. min 1, max 365 |

## Output

Results are wrapped in an envelope: `tool`, `version`, `requestId`, `data`, `summary`, `meta` (cache status, timing), `permalink`. `data` has these fields:

| Field | Type | Description |
|---|---|---|
| `domain` | string |  |
| `mode` | "expiry" \| "readiness" |  |
| `asOf` | string |  |
| `limits` | object[] |  |
| `summary` | object |  |
| `hosts` | object[] |  |
| `notChecked` | object[] | Hosts past the 20 that are checked. |
| `ctHistory` | object |  |
| `recommendations` | object[] |  |
| `feed` | object |  |

## Examples

### lookupowl.com and its mail host

```json
{"domain":"lookupowl.com","mode":"readiness","useCtHistory":true,"includeDomainExpiry":true,"warnDays":21}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/cert-expiry-check?domain=lookupowl.com&includeDomainExpiry=true&mode=readiness&useCtHistory=true&warnDays=21'
```

Web page: https://lookupowl.com/certificate-lifetime-readiness?q=lookupowl.com

### Five well-known hosts

```json
{"domain":"lookupowl.com","hosts":["github.com","cloudflare.com","google.com","paypal.com"],"mode":"readiness","useCtHistory":true,"includeDomainExpiry":true,"warnDays":21}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/cert-expiry-check?domain=lookupowl.com&hosts=github.com&hosts=cloudflare.com&hosts=google.com&hosts=paypal.com&includeDomainExpiry=true&mode=readiness&useCtHistory=true&warnDays=21'
```

Web page: https://lookupowl.com/certificate-lifetime-readiness?q=lookupowl.com&hosts=github.com&hosts=cloudflare.com&hosts=google.com&hosts=paypal.com

### An expired certificate (badssl.com)

```json
{"domain":"expired.badssl.com","mode":"expiry","useCtHistory":true,"includeDomainExpiry":true,"warnDays":21}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/cert-expiry-check?domain=expired.badssl.com&includeDomainExpiry=true&mode=expiry&useCtHistory=true&warnDays=21'
```

Web page: https://lookupowl.com/ssl-certificate-expiry-checker?q=expired.badssl.com

### One host: github.com

```json
{"domain":"github.com","mode":"expiry","useCtHistory":true,"includeDomainExpiry":true,"warnDays":21}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/cert-expiry-check?domain=github.com&includeDomainExpiry=true&mode=expiry&useCtHistory=true&warnDays=21'
```

Web page: https://lookupowl.com/ssl-certificate-expiry-checker?q=github.com

## Web pages

- https://lookupowl.com/certificate-lifetime-readiness
- https://lookupowl.com/ssl-certificate-expiry-checker

## Limits and caching

- Cost: from 1 unit up, depending on the input (a registry lookup counts every upstream request); 1 unit for a cached result. Budgets are per network and published in the `RateLimit` response headers.
- Cache: results are kept for 600 s. Add `fresh=true` (MCP argument or query parameter) to look again; it costs 3 units per unit and is limited to 10 per hour.
- Timeout: 30 s.

## Related tools

- [SSL Certificate Checker](https://lookupowl.com/tools/ssl-checker.md): Check a site's SSL/TLS certificate: days until it expires, whether it is trusted, matches the host and has a complete chain.
- [Certificate Transparency Search](https://lookupowl.com/tools/ct-search.md): Every certificate logged in Certificate Transparency for a domain: who issued it, when, and for which names. A fast crt.sh alternative.
- [CAA Record Checker](https://lookupowl.com/tools/caa-check.md): Check which certificate authorities may issue certificates for a name, and whether any certificate was issued that the CAA does not allow.
- [Certificate and CSR Decoder](https://lookupowl.com/tools/x509-decode.md): Read a certificate, chain or CSR field by field: names, validity, key, fingerprints and lint findings. It runs in your browser.
- [Security Headers Checker](https://lookupowl.com/tools/security-headers.md): Grade a site's HTTP security headers from A+ to F, with what each one does and the exact header to add.
- [WHOIS Lookup](https://lookupowl.com/tools/whois-lookup.md): Registrar, creation and expiry dates, status codes, nameservers and DNSSEC for any domain, from RDAP with WHOIS fallback.

## Guide: Certificate lifetime readiness

Check whether the certificates on your hosts are ready for the shorter lifetimes that start in 2027.

### The new limits

The longest lifetime a publicly trusted TLS certificate may have is set by the CA/Browser Forum, where browsers and certificate authorities agree the rules (ballot SC-081). It is counted from the day a certificate is issued, so a certificate you already have keeps its full life. What changes is what your authority may issue the next time you renew.

| Issued from | Longest lifetime | Set by |
|---|---|---|
| Before 2026-03-15 | 398 days | CA/Browser Forum |
| 2026-03-15 | 200 days | CA/Browser Forum |
| 2027-02-10 | 64 days (default) | Let's Encrypt, its own programme |
| 2027-03-15 | 100 days | CA/Browser Forum |
| 2029-03-15 | 47 days | CA/Browser Forum |

The Let's Encrypt row is a default that one authority chooses, not a rule for everyone, so the result draws it with a dashed outline. The time an authority may reuse a proof that you control a domain shrinks on the same dates, which is one more reason renewal has to be automatic by 2029.

### What this check tells you

1. **List your hosts**: Type one name in the first box and up to 20 more below it, one per line, as `host` or `host:port`. Use real names, since a wildcard such as `*.example.com` is a certificate, not a host.
2. **Read the verdict**: The top of the result says how many hosts pass the 2027 rule and how many could cope with 47 days. A host that is expired, not trusted or answering for another name is counted as checked, with a problem. A host that did not answer is left out of the verdict and says so.
3. **Open the rows that need action**: Rows are sorted with the hosts that need action first. Each shows the lifetime, the days left, two marks for 2027 and 2029 and, when you open it, the renewal evidence, the dates and what to change.

> **A pass is not a promise** We read the certificate each host serves now. Whether renewal is automatic is a judgement from public logs, and when the logs are not available we say that we can't tell instead of guessing.

### How to read the lifetime bars

Every host gets a bar on the same axis, from 0 to 200 days. The darker part is the time the certificate has already been in use and the light part is the time left. Three thin lines mark 47, 100 and 200 days. A certificate of 90 days ends between the 47 and 100 lines, which is where most automated certificates sit. One of 198 days ends just short of the 200 line and passes the 100 line, so you can see the problem without reading a number.

A certificate longer than 200 days is drawn to the edge of the axis and the row says its real length. The words under each bar say the same thing as the picture, because a drawing is never the only place a fact appears.

### Is renewal automatic?

A 90-day certificate is ready for the 100-day rule today, but 47 days comes round so often that only automatic renewal works. The check looks for evidence in four places and shows each one in the row.

- **Renewal history.** Public Certificate Transparency logs show every certificate issued for a name. At least three certificates of 100 days or less, each issued before the last one ran out, read as automated. Long certificates replaced about once a year, or a replacement that came after the old one ended, read as manual. Anything else is "can't tell".
- **A delegated `_acme-challenge` name.** A CNAME at `_acme-challenge.<host>` hands the DNS-01 proof to a service built for renewing, which is a good sign.
- **CAA with `accounturi` and `validationmethods`.** These parameters (RFC 8657) tie issuance to your own ACME account and method. They are not required, and they are what an automated setup tends to use.
- **Renewal information (ARI).** Some authorities publish when a certificate should be renewed (RFC 9773). We read the authority's ACME directory and report "yes", "no" or "unknown", and unknown is never counted against you.

Renewing when about a third of the lifetime is left is a common practice and what Let's Encrypt suggests. It is advice, not a requirement, so the page never treats a host as late for renewing at another time.

### What to do before 2027-03-15

- **Move every long certificate to automation first.** Hosts of 198 days or more are the ones the check flags for 2027. Ask your authority for certificates of 90 days or less and renew them with an ACME client.
- **Test a renewal end to end.** Run one on purpose, confirm the new file was written and that the service reloaded to use it.
- **Find the hosts nobody owns.** Staging, mail, VPN and admin hosts often have a hand-installed certificate. The [subdomain finder](https://lookupowl.com/subdomain-finder) helps you list them, then paste the names here.
- **Watch for a server that serves an old certificate.** When a name has several addresses, one stale node still reaches visitors. The row says how many addresses differ and uses the lowest days left.
- **Plan for 47 days now.** Delegate `_acme-challenge`, bind CAA to your account and make sure a failed renewal raises an alert well before expiry. A [CAA check](https://lookupowl.com/caa-checker) shows who may issue for you today.

### How the check works

For each host LookupOwl resolves the name, checks that every address is public, completes one TLS handshake with the right server name and reads the certificate. It then reads the other addresses of the name to see if they serve the same one. Up to 21 hosts are checked, five at a time, each with a few seconds to answer. Private names and addresses are never contacted. The rest, which is CAA, the `_acme-challenge` name, the authority's directory, the logs and the registration date of each domain, is read only when it adds something and is skipped when it cannot be read.

The host list is sent to our server to run the check and is not stored. The certificate details come from the [SSL checker](https://lookupowl.com/ssl-checker), and renewal history comes from the same logs as the [certificate search](https://lookupowl.com/certificate-transparency-search).

### Frequently asked questions

**Do the new limits apply to every certificate?**

They apply to publicly trusted TLS certificates, the ones browsers accept from public authorities. Certificates from your own private authority are not covered, and a host that uses one shows up here as not trusted rather than as a readiness problem.

**Will my existing certificate stop working in 2027?**

No. The limit applies on the day a certificate is issued, so a certificate keeps working until it expires. What changes is that your next certificate may be at most 100 days long, then 47 days from 2029, and renewal has to keep up.

**How do you know if renewal is automatic?**

We look at how often a host's certificate was replaced in public logs, and whether replacements came before the old one ended. Without that history we judge only the certificate being served now and the row says "can't tell".

**Why is a 90 day certificate marked "not yet" for 2029?**

Because 90 days is longer than 47. It is fine today, and it can be fine in 2029 if renewal is automatic and the authority issues shorter ones. The mark says what the certificate is now, and the renewal evidence says whether it can change.

**What does an unknown or "can't tell" mean?**

It means we could not see enough to say, for example when the logs are down or a name has few certificates. It is never counted as a pass or as a fail.

**Why is the Let's Encrypt line dashed?**

Because it is that authority's own default, not a rule of the CA/Browser Forum. Other authorities keep issuing up to the Forum limit, which is why the strip lists both.

**Can I check hosts on a port other than 443?**

Yes, as `host:port`, on 465, 587, 636, 853, 993, 995 and 8443 as well. Mail submission on 587 asks the server to switch to TLS first. We never send a message or log in.
