Free SSL certificate checker — A+ to F grade, full chain, HSTS, CAA, PFS, and AI-powered fix snippets for any website.

Most SSL checkers stop at 'valid until X'. This tool goes deeper by combining a live handshake, DER-level extension parsing, a real TLS version probe, HSTS + CAA inspection, a computed grade, and an AI diagnosis with copy-paste fixes.

The report is grouped into six tabs. Every field is derived from the DER-encoded certificate or the live TLS session — no third-party lookups, no inference.

• Certificate identity Subject + issuer with CN, organization, country, state, locality decoded from the X.509 DN. Serial number, SHA-1 + SHA-256 fingerprints, PEM download of the leaf.
• Cryptography Public key type (RSA / ECDSA / Ed25519 / Ed448), bits or curve (P-256, P-384, P-521), signature algorithm with OID lookup + weak-flag detection (SHA-1, MD5 all flagged critical).
• Validity + Extensions Valid-from / valid-to with days remaining, expiry countdown (red < 7d, amber < 30d), lifetime + age. Key usage / extended key usage from cert extensions. Wildcard flag, CA cert flag, OCSP URL, CA Issuers URL, must-staple flag.
• Subject Alternative Names Full SAN list — searchable, downloadable as JSON or CSV, wildcard entries highlighted. Cloudflare-style certs with 100+ SANs render smoothly.
• Certificate Transparency SCT count extracted directly from the CT extension DER (OID 1.3.6.1.4.1.11129.2.4.2). Modern Chrome requires at least 2 embedded SCTs — the report tells you exactly how many are baked into the cert.
• Validation level (DV/OV/EV) Detected from Certificate Policies extension OIDs. CA/B Baseline Requirements Reserved OIDs (2.23.140.1.*) win when present; falls back to a curated CA-specific EV OID list; subject-field heuristic covers the rest.
• Full chain of trust Every certificate from leaf to root, each tagged with its type (End-Entity / Intermediate / Root). Chain issues surfaced: missing intermediate, broken link (issuer/subject mismatch), expired intermediate, weak signature on a non-root cert.
• TLS version matrix Per-version probe results with the cipher negotiated at that version. Handshake time (ms), remote IP, SNI hostname, authorized-by-trust-store flag + any authorization error string.
• Security features HSTS (present + max-age + subdomains + preload + preloadable), CAA (records + tags + critical flag), OCSP URL published, OCSP Must-Staple, CT SCTs, PFS + ephemeral key type + bits, ALPN, secure renegotiation.

Five factors, each scored 0-100, combined with a weighted average. Any critical weakness (expired cert, hostname mismatch) triggers a hard cap. A+ requires excellence across all factors — not just an A.

• Certificate (25%) Key strength (RSA < 2048 = weak, ECDSA P-256+ = strong), signature algorithm strength (SHA-1 = weak = capped at 40), days remaining (< 14 days = capped at 60).
• Key Exchange (25%) Perfect Forward Secrecy check. ECDHE / DHE ephemeral key = 100. No ephemeral key = 60. Session compromise past traffic risk.
• Cipher Strength (20%) Modern AEAD (GCM, ChaCha20-Poly1305) = 100. CBC-mode non-AEAD = 80. RC4 / DES / EXPORT / NULL cipher = 20 (major failure).
• Protocols (20%) TLS 1.3 supported = 100. TLS 1.2 only = 90 max. TLS 1.1 still enabled = 70 max. TLS 1.0 still enabled = 60 max (PCI-DSS non-compliant). No modern TLS = 20.
• Features (10%) 40 pts for HSTS, +15 preloadable, +15 CAA, +20 CT SCTs embedded, +10 OCSP Must-Staple. Capped at 100.
• A+ criteria A grade AND HSTS preloadable AND TLS 1.3 supported AND TLS 1.0/1.1 disabled AND PFS via ECDHE/DHE AND CT SCTs embedded. Anything less is at most A.
• Hard caps (grade → F territory) Expired certificate → F automatically. Trust chain error (self-signed, hostname mismatch, unknown CA) → capped at 50.

TLS misconfigurations are the most common cause of preventable outages, the most common audit finding, and the easiest class of mistake to catch automatically.

• Certificate expiry takes sites down regularly. Microsoft, LinkedIn, GitHub, Equifax, and almost every Fortune 500 has had a public outage caused by an expired cert in the last decade. Automated renewal (Let's Encrypt, ACME) helps but breaks silently when the renewal process itself fails. A daily SSL check is the cheapest insurance policy in operations.
• Deprecated protocols still on = compliance violation. TLS 1.0 and 1.1 were formally deprecated by IETF in 2021 (RFC 8996). Both are vulnerable to BEAST; TLS 1.0 also to POODLE-equivalent attacks. Still enabled on many production servers because nobody audited them after the initial setup — the exact configuration mistake PCI-DSS 4.0 catches.
• Chain misconfigurations break for some clients only. Servers that don't send intermediate certs work in Chrome (which fetches missing intermediates via AIA) but fail in Java, curl, mobile apps, and older browsers. The check passes superficially while a meaningful slice of clients silently break.
• Missing HSTS = downgrade attack on first visit. Without HSTS, browsers accept an attacker-injected HTTP redirect on the first visit — SSLstrip-style downgrade. HSTS with `preload` is the only cure, and 'A+' requires it. This tool flags the exact directive missing from your header.
• No CAA = any CA can issue for your domain. Post-2017 all CAs must honour CAA records. Publishing a CAA record limiting issuance to your own CA is a 60-second DNS change that eliminates an entire class of mis-issuance attacks. This tool tells you if you have one.

No shell-out to openssl (which is fragile across builds). Everything runs on Node's native tls + crypto.X509Certificate, plus a minimal DER walker for extensions the standard API doesn't expose.

• Stage 1 — Live handshake on port 443 Node tls.connect with SNI + ALPN advertised. Captures negotiated protocol, cipher, ephemeral key, and the full peer certificate chain. All in one round trip.
• Stage 2 — Parse the leaf certificate crypto.X509Certificate extracts subject / issuer / SANs / OCSP + CA-Issuers URLs (from AIA), CA flag. Minimal DER walker extracts signature algorithm OID, certificate policy OIDs, CT SCT count, must-staple flag.
• Stage 3 — Chain typing Walk the returned chain top-to-bottom. Position 0 = End-Entity. Self-signed (subject == issuer) = Root. Middle = Intermediate. Each cert re-parsed at the same depth as the leaf.
• Stage 4 — TLS version probe (parallel) Four parallel tls.connect calls, each pinning min/max version to a single TLS release. Handshake success = enabled + cipher negotiated. Failure = disabled + error code.
• Stage 5 — HSTS + CAA (parallel) HTTPS GET to the root captures the Strict-Transport-Security header. dns.resolveCaa on the registered domain (via psl for eTLD+1 detection) captures CAA. Both run in parallel with the TLS probes — total latency ≈ single handshake time.
• Stage 6 — Grade + checks + AI Weighted grade formula runs on the assembled report. 15 pass/warn/fail checks generated for the Security Features tab. AI diagnosis enqueued to Gemini with the full JSON — the poll pattern returns immediately with a meta pointer, browser polls until ready.

A TLS certificate is an X.509 document with a fixed set of fields. Most follow the X.500 Distinguished Name standard from the 1980s. Two groups — identity (subject + issuer) and cryptography (validity, serial, fingerprints, keys):

• CN — Common Name Historically the hostname the certificate is for. In 2026 CN is effectively legacy — modern browsers ignore it for hostname validation and use SAN entries instead.
• O — Organization Legal organisation name. For DV certs (Let's Encrypt) usually blank. For OV / EV certs the CA has verified the organisation's legal existence.
• SAN — Subject Alternative Name The list of hostnames the certificate is actually valid for. This is what browsers use in 2026 — a single cert can carry hundreds of SANs (Cloudflare's shared certs cover ~150). Wildcards like `*.example.com` live here.
• validFrom / validTo Cert lifetime. CA/Browser Forum caps maximum validity at 398 days (about 13 months) since 2020. Let's Encrypt defaults to 90 days on purpose — automation is expected.
• Serial Number Unique identifier within the issuing CA. Used in revocation lookups and audit trails. Hex-encoded, typically 16-20 bytes.
• Fingerprint (SHA-256) 32-byte hash of the certificate. Current standard for pinning, comparison, and audit trails. SHA-1 fingerprint is also shown for legacy compat but SHA-1 itself is cryptographically broken since 2017.
• Public Key Algorithm RSA (2048-bit minimum, 4096 common) or ECDSA (P-256 / P-384 — smaller, faster, mathematically equivalent strength). Ed25519 is landing in some ecosystems. ECDSA is preferred for new deployments.
• Signature Algorithm How the CA signed the certificate. Modern certs use SHA-256-with-RSA or ECDSA-with-SHA256. SHA-1 based signatures were deprecated by browsers in 2017 — this tool flags them critical.
• Certificate Policies OIDs that identify the validation level and any CA-specific policy. CA/B Baseline Requirements Reserved OIDs (2.23.140.1.2.1 = DV, 2.23.140.1.2.2 = OV, 2.23.140.1.1 = EV) are the standard signal.
• Authority Information Access (AIA) OCSP responder URL (real-time revocation status) + CA Issuers URL (where to fetch missing intermediates). Modern browsers use AIA to fill in gaps in the chain, but not every client does — always ship the full intermediate chain.
• OCSP Must-Staple (RFC 7633) A TLS-Feature extension that tells clients to hard-fail if no fresh OCSP response is stapled to the handshake. Protects against forged 'good' OCSP answers after cert revocation.
• Certificate Transparency SCTs Signed Certificate Timestamps embedded in the leaf. Modern Chrome requires at least 2 SCTs from independent CT logs. This tool counts them directly from the DER.

TLS versions are a chronological story of attacks and patches. Six protocol versions have been deployed at some point. Today, only two should be enabled.

• SSL 2.0 (1995) — Deprecated, never enable Full of fundamental flaws (no truncation protection, weak MAC, keys reused for encrypt + auth). Formally deprecated by IETF in 2011.
• SSL 3.0 (1996) — Killed by POODLE Significantly better than 2.0 but still vulnerable. POODLE attack (2014) demonstrated practical exploitation. Deprecated by IETF in RFC 7568 (2015).
• TLS 1.0 (1999) — Deprecated 2021 (RFC 8996) Internally SSL 3.1 — same wire format with fixes. Vulnerable to BEAST (2011). Disabled by all major browsers in 2020. Still enabled on some servers — this tool flags them.
• TLS 1.1 (2006) — Deprecated 2021 (RFC 8996) Added explicit IV (fixing BEAST proactively). Deprecated by the same RFC in 2021.
• TLS 1.2 (2008) — Current minimum baseline Authenticated encryption (AEAD ciphers), SHA-256 by default. The minimum required by PCI DSS, HIPAA, and most compliance frameworks.
• TLS 1.3 (2018) — Current best Smaller, faster handshake (1 round-trip vs TLS 1.2's 2). Dropped RSA key exchange, CBC ciphers, SHA-1, MD5, static DH. Only modern AEAD ciphers and ECDHE/DHE forward-secret key exchanges.

Every field on this page is available as JSON. Useful for expiry-monitoring crons, CI gates on production deploys, compliance audits, and SSL/TLS regression testing.

const res = await fetch(
  'https://api.domainscan.in/v1/security/ssl-info?domain=github.com'
);
const {data: report} = await res.json();

console.log(report.grade.letter);               // 'A+'
console.log(report.grade.score);                // 99
console.log(report.certificate.public_key.label); // 'ECDSA P-256'
console.log(report.certificate.validity.days_remaining); // 82
console.log(report.handshake.protocol);         // 'TLSv1.3'
console.log(report.handshake.cipher.name);      // 'TLS_AES_256_GCM_SHA384'
console.log(report.handshake.pfs);              // true
console.log(report.protocols['TLS 1.0'].enabled); // false
console.log(report.hsts.preloadable);           // true
console.log(report.caa.records.length);         // 7
console.log(report.certificate.cert_transparency.sct_count); // 3
console.log(report.certificate.validation_level); // 'OV'

// Days until expiry — the metric to alert on
if (report.certificate.validity.days_remaining < 30) {
  console.warn('Cert renewal window opening — automate now.');
}

{
  "found": true,
  "domain": "github.com",
  "fetchedAt": "2026-07-18T…",
  "connection": { "remoteAddress": "…", "port": 443, "handshakeMs": 234, "authorized": true },
  "certificate": {
    "subject": { "common_name": "github.com", "organization": "…" },
    "issuer":  { "common_name": "…", "organization": "Sectigo" },
    "validity": { "from": "ISO", "to": "ISO", "days": 90, "days_remaining": 82, "is_expired": false },
    "serial_number": "…",
    "fingerprint":    "SHA-1  colon-separated",
    "fingerprint256": "SHA-256 colon-separated",
    "public_key": { "type": "EC", "bits": 256, "curve": "prime256v1", "strength": "strong", "label": "ECDSA P-256" },
    "signature_algorithm": { "oid": "…", "name": "SHA256-RSA", "hash": "SHA256", "weak": false },
    "subject_alt_names": ["github.com", "www.github.com"],
    "san_count": 2,
    "is_wildcard": false,
    "validation_level": "OV",
    "cert_transparency": { "embedded": true, "sct_count": 3 },
    "ocsp": { "urls": ["…"], "must_staple": false }
  },
  "chain": [ { "position": 0, "type": "EndEntity", "…": "…" } ],
  "chain_issues": [],
  "handshake": { "protocol": "TLSv1.3", "cipher": { "name": "…" }, "pfs": true, "ephemeral_key": { "type": "ECDH", "name": "X25519", "size": 253 }, "alpn": "h2" },
  "protocols": {
    "TLS 1.3": { "enabled": true, "cipher": "…" },
    "TLS 1.2": { "enabled": true, "cipher": "…" },
    "TLS 1.1": { "enabled": false, "error": "…" },
    "TLS 1.0": { "enabled": false, "error": "…" }
  },
  "hsts": { "present": true, "max_age": 31536000, "include_subdomains": true, "preload": true, "preloadable": true },
  "caa":  { "present": true, "records": [ { "tag": "issue", "value": "digicert.com" } ] },
  "grade": { "letter": "A+", "score": 99, "factors": { "certificate": { "…": "…" }, "…": "…" } },
  "tests":     [ { "id": "…", "category": "…", "status": "pass|warn|fail|info", "message": "…" } ],
  "compliance": { "pci_dss": true, "hipaa_ready": true, "modern_browsers": true, "warnings": [] },
  "AiAnalysis": { "summary": "…", "quick_recommendations": ["…"], "security_assessment": [], "fixes": [] }
}

• What's the difference between SSL and TLS? SSL (Secure Sockets Layer) is the older name; TLS (Transport Layer Security) is the renamed successor. SSL 2.0 and 3.0 are obsolete; TLS 1.0 through 1.3 are versions of the modern protocol. When someone says 'SSL certificate' in 2026 they almost always mean a TLS certificate.
• How is the A+ to F grade calculated? Five factors weighted: Certificate 25%, Key Exchange 25%, Cipher Strength 20%, Protocols 20%, Features 10%. The lowest factor caps the total — a weak signature algorithm drags down an otherwise perfect setup. A+ requires excellence across all factors: HSTS preloadable, TLS 1.3, PFS, CT SCTs, no deprecated TLS.
• What is HSTS preload and why do I need it? HSTS tells browsers 'always use HTTPS for this domain'. Without it, the first request in a session can still be HTTP — attackers can inject a downgrade there. Preload adds your domain to a hardcoded list shipped with Chrome / Firefox / Safari, closing the first-visit gap. Preloadable status requires max-age ≥ 1 year, includeSubDomains, and the preload directive. Submit at hstspreload.org once eligible.
• What's a CAA record and should I add one? A DNS record (RFC 8659) telling every CA on the planet which ones are allowed to issue certificates for your domain. If you always use Let's Encrypt, publish `0 issue "letsencrypt.org"` — any other CA that ignores this is out of compliance. Takes 60 seconds, closes an entire class of mis-issuance attack.
• What is Perfect Forward Secrecy (PFS)? The server generates a fresh ephemeral key for each session (ECDHE or DHE) so past traffic stays safe even if the server's private key is later compromised. TLS 1.3 requires PFS. TLS 1.2 supports it but doesn't require it — always negotiate ECDHE cipher suites first.
• What is Certificate Transparency (CT)? Every certificate issued by a public CA must be logged in independent CT logs. Modern Chrome requires at least 2 SCTs (Signed Certificate Timestamps) embedded in the cert. Missing SCTs = Chrome rejects the certificate. This tool counts them directly from the DER.
• How often should I check my SSL certificate? For production: daily, automated. Cert expiry is the #1 preventable outage cause. For deploys: after every cert-touching change. For compliance: quarterly with retained evidence. The API supports all three patterns.
• Why is TLS 1.0 / 1.1 still enabled on my server? Usually because the default config of older web servers (Apache, nginx, IIS) included them, and nobody explicitly disabled them. The fix is a one-line config change (`ssl_protocols TLSv1.2 TLSv1.3;` in nginx). All major browsers dropped TLS 1.0/1.1 support in 2020 — you're not breaking real users.
• What is DV vs OV vs EV validation? DV (Domain Validated) = CA verified you control the domain. Fast, cheap, automated — Let's Encrypt is DV. OV (Organization Validated) = CA also verified your legal organisation exists. EV (Extended Validation) = CA did a deep organisation background check. Modern browsers show no visible UI difference — the trust value of EV is largely gone since 2019 when Chrome removed the green address bar.
• How do I get a free SSL certificate? Let's Encrypt is the dominant free CA — DV certs, 90-day validity, ACME auto-renewal. ZeroSSL, Buypass, Cloudflare also issue free certs. For OV/EV expect to pay a CA fee.