If you’ve ever needed to find out which certificates and subdomains exist for a domain, you’ve probably ended up on crt.sh. It has been the default Certificate Transparency search tool for years, and it’s free. It’s also slow on large domains, it returns thousands of near-duplicate rows, and it only tells you what was issued, not what your servers are doing today.

SSLBoard covers the same ground in four tools. Recent certificates answers the question most people open crt.sh for, which is what was just issued for a name, with the newest certificates at the top and results in seconds. A subdomain map turns the same Certificate Transparency data into a picture you can read at a glance. ctlog prints a clean hostname list for your recon pipeline. And a live TLS scan checks which certificates, protocols, and ciphers every host is actually serving. None of them needs an account.

The quickest way to compare is to run your own domain through it:

Try it on your domain

Or see a live example: github.com, airbus.com, shopify.com.

What is crt.sh?

crt.sh is a free Certificate Transparency log search run by Sectigo. It ingests the public CT logs and lets you query them by domain, SAN, issuer, serial number, or SHA-256 fingerprint. Type %.example.com and you get every logged certificate for that domain and its subdomains, including pre-certificates, expired certificates, and certificates from CAs you never authorized.

Adding &output=json to a search returns structured JSON, which is what most scripts and subdomain enumeration tools use. There’s an RSS feed per identity for new issuances, and Sectigo exposes the underlying certwatch database over PostgreSQL, so you can run your own SQL against the CT dataset.

Why people look for a crt.sh alternative

It’s slow and it times out. crt.sh is a shared public service. Searches for large domains regularly take a long time or fail with errors, which is painful when you’re in the middle of an investigation or a script depends on it.

A table of certificates is not a subdomain list. A search for a mid-sized organization returns thousands of rows, most of them expired, many of them duplicate pre-certificate and leaf pairs, with the same hostnames repeated across years of renewals. Working out which subdomains exist and where the bulk of them sit is left to you.

CT logs describe issuance, not deployment. A certificate appears in a log because a CA issued it. Nothing in that record says whether it was ever installed, whether it’s serving traffic today, or whether the old certificate is still live on two of your five load balancer nodes.

No TLS analysis. crt.sh never connects to your servers. It can’t tell you which protocol versions your endpoints negotiate, which cipher suites they accept, or whether forward secrecy holds. A domain with a clean crt.sh page can still be answering on TLS 1.0 with 3DES.

No DNSSEC or CAA check. crt.sh indexes certificates. It doesn’t check whether your zone is signed or whether you’ve published CAA records restricting which CAs can issue for you.

Nothing to hand to anyone else. The output is a table in a browser tab or raw JSON. If you need to send a colleague something they can act on, you’re building that yourself.

Recent certificates: what was issued, newest first

Most crt.sh searches are about one name and one recent event. A renewal ran overnight and you want to know whether a new certificate exists. A browser shows an unexpected issuer and you want to see who signed what. A deploy failed and you need the serial of the certificate the CA just handed out. On crt.sh that means waiting for the query, then scrolling past years of renewals to find yesterday.

Recent certificates only keeps the last few days of Certificate Transparency entries, so the answer is at the top of the page. Type a domain and you get the certificates logged for it and its subdomains, sorted by the time they reached the logs and grouped by day. Each row shows the hostname, the issuing CA, how long the certificate is valid, and the validation and key type. Click a row for the serial, the full issuer, the signature algorithm, the SPKI hash and every name on the certificate. Switch to “Exact name” to see only certificates naming that one host, or filter the list by name or by CA.

Some things are easy to spot there and hard to find on crt.sh:

  • Did my renewal go through? If the new certificate isn’t in the list a few minutes after your ACME client ran, the problem is on the issuance side, not on your servers.
  • Who is issuing for my domain? The issuer breakdown shows every CA that signed something for you in the last few days. A name you don’t recognize is worth a look, and CAA records are how you stop it.
  • What changed on that subdomain? A team that moved a host to a CDN or a new load balancer usually leaves a fresh certificate behind, issued by a different CA.

The search runs in the browser, and every search has its own link, such as sslboard.com/certificates/?q=github.com, so you can paste it into a ticket or a chat thread. Without an account you see the 100 newest certificates for a domain. From a terminal, ctlog certificates example.com returns the same data as JSON.

A certificate in the list proves that a CA issued it, and nothing more. To check that it reached every server, run the TLS scan described below.

SSLBoard’s subdomain map: CT data you can read

The SSLBoard subdomain map answers the question most people bring to crt.sh: which subdomains does this domain have? Type a domain and SSLBoard builds a treemap of its hostnames from public Certificate Transparency logs. Each box is a branch of the domain, sized by how many hostnames it contains, so the largest parts of an organization’s footprint stand out immediately.

It works on any domain, yours or someone else’s. It doesn’t scan or connect to anything, so it’s safe for reconnaissance, vendor research, or sizing up an acquisition target. Every map has its own link, like sslboard.com/subdomain/github.com, so you can share it without exporting anything.

ctlog: hostnames for your scripts, without the cleanup

If you use crt.sh from a terminal, the usual routine is curl with output=json, then jq to pull out name_value, then splitting, stripping *., lowercasing and sort -u, assuming the request didn’t time out first. ctlog replaces all of that with one command:

go install github.com/sslboard/ctlog@latest
ctlog example.com | httpx

It returns every hostname on the domain’s currently valid certificates, already normalized and deduplicated, one per line on stdout. Notices go to stderr, so nothing else ends up in the pipe. Prebuilt binaries for Linux, macOS and Windows are on GitHub.

Existing scripts can keep their jq filter: ctlog example.com -o crtsh returns crt.sh-shaped JSON with the hostname in name_value. The same data is available without the CLI from https://sslboard.com/api/v1/hostnames?q=example.com, in JSON, plain text, or the crt.sh shape.

There are two differences from crt.sh worth knowing. ctlog lists hostnames, not certificates, so issuer, serial and validity dates are not included. And it covers certificates that are valid today plus a 15-day grace period after expiry, not the full history crt.sh keeps. For recon that is usually the point, since an expired name from 2019 rarely leads anywhere. Without an account a search returns up to 100 hostnames and you can run one search per minute.

From discovery to deployment: the TLS scan

The map shows you what exists. The scan shows you what’s actually running. Type a domain on sslboard.com and SSLBoard discovers hostnames through Certificate Transparency and DNS enumeration, then performs live TLS handshakes against every resolved IP.

The report covers certificates (expiration timelines, issuer distribution, key types and sizes, SAN coverage, chain problems), protocol versions with the CVEs tied to anything outdated, cipher suites including 3DES, RC4, EXPORT, NULL and CBC-mode issues mapped to the hosts that accept them, forward secrecy, HTTP security such as redirect behaviour and HSTS headers, DNSSEC and CAA policy, connection errors like self-signed certificates and name mismatches, and post-quantum readiness.

Findings roll into a weighted score by category, each one ranked by severity and linked to the affected hosts. Reports are shareable by link and exportable as CSV, Markdown, and JSON.

The practical difference: crt.sh tells you a certificate for api.example.com was issued in June. SSLBoard tells you api.example.com is still serving the February certificate on one of its three IPs, and that the endpoint accepts TLS 1.0.

crt.sh vs SSLBoard at a glance

crt.shSSLBoard
Data sourceCertificate Transparency logsCT logs, DNS, and live TLS handshakes
Recent issuance for a domainMixed into the full history, often slowNewest first, last few days, in seconds
Subdomain discoveryRaw certificate rowsVisual subdomain map, one link per domain
Command-line toolNo, curl plus jqctlog, clean hostname list
Hostname APIJSON, often slow on large domainsJSON, plain text, or crt.sh-shaped JSON
Expired certificatesFull history15 days after expiry
Shows what’s deployed todayNoYes, per host and per IP
Protocol and cipher checksNoYes
DNSSEC and CAANoYes
Prioritized findings and scoreNoYes
Lookup by serial or fingerprintYesNo
Raw SQL accessYesNo
ExportsJSONCSV, Markdown, JSON
PriceFreeSearches, map and scan free, full report paid

When to use crt.sh vs SSLBoard

Keep crt.sh around for certificate forensics: looking up a specific serial number or fingerprint, checking whether a CA logged something it shouldn’t have, digging into expired certificates, or querying the CT dataset directly with SQL.

Use SSLBoard when you want the answer rather than the rows. Recent certificates tells you what was just issued for a name, which is what most debugging sessions need. The subdomain map is the quick way to see a domain’s footprint. ctlog feeds the same hostnames to httpx, dnsx or nuclei without a cleanup step. The scan is the way to confirm that a certificate rotation actually landed everywhere, to prepare for a compliance review, or to answer “how does our TLS look?” with something you can share.

If what you actually want is expiration reminders, SSLCalendar is a simpler fit. Enter a domain and an email address, then subscribe to an ICS feed in Google Calendar, Outlook, or Apple Calendar. It uses SSLBoard’s active-certificate checks, so it reminds you about certificates that are serving traffic rather than everything that ever appeared in a log.

Getting started

To see what was issued for a domain in the last few days, search recent certificates and type the domain. Results come back in seconds and need no account.

To see a domain’s subdomains, open the subdomain map and type the domain.

To get the hostname list in a terminal, install ctlog with go install github.com/sslboard/ctlog@latest or grab a binary from the releases page. The ctlog docs cover the flags, the API, and migrating crt.sh scripts.

To check what those hosts are serving, go to sslboard.com, type your domain, and wait a few minutes. The scan is free and shows your score and findings without an account. The first scan guide walks through what to expect. The full report with per-host breakdowns and exports costs $9 for 15 endpoints or fewer and $49 above, with 30 days of free retests included.

Photo by Javier Allegue Barros on Unsplash