Open Tools LibraryOpen Tools Library
Security & Privacy

SSL/TLS Certificate Decoder

Decode any X.509 certificate's real fields — subject, issuer, validity, SANs — from a from-scratch parser, verified against Node's own crypto engine.

Also known as: X.509 decoder, Certificate viewer, SSL cert parser, PEM decoder

100% FreeNo Signup RequiredRSA & EC SupportVerified vs Node.js crypto
100% local — nothing you enter here ever leaves this browser tab
Loading tool…
Step by step

How it works

  1. 1Paste a PEM-encoded certificate (including the BEGIN/END CERTIFICATE lines), or upload a .pem/.crt/.cer file.
  2. 2Review the decoded subject, issuer, and validity status at a glance.
  3. 3Check serial number, signature algorithm, and public key details further down.
  4. 4Review Subject Alternative Names and other extensions, including any marked critical.
Why OTL

Why use SSL/TLS Certificate Decoder

Full field decode

Subject, issuer, validity, serial number, signature algorithm, public key, and extensions — all extracted from the raw certificate bytes.

RSA and EC key support

Correctly computes RSA key size and identifies named EC curves like P-256, P-384, and P-521.

Instant expiry status

See at a glance whether a certificate is valid, not yet valid, or already expired, with exact days remaining.

Verified parser correctness

Checked field-by-field against Node.js's own crypto.X509Certificate on RSA, EC, and expired test certificates before use.

Real Subject Alternative Name parsing

Decodes the actual GeneralNames structure, not just a byte count — DNS names, IPs, emails, and URIs are all shown individually.

Nothing uploaded

Certificate data is parsed entirely in your browser, never sent to a server.

Real-world use

Who uses SSL/TLS Certificate Decoder

Checking when a certificate expires

Confirm exactly how many days remain before a certificate needs renewal, before it causes an outage.

Inspecting a self-signed development certificate

See exactly what's inside a locally generated cert used for local HTTPS development.

Verifying a SAN list covers all needed domains

Confirm every domain and subdomain a certificate needs to cover is actually listed in its Subject Alternative Names.

Debugging a certificate configuration issue

Check the exact subject, issuer, and key details a server is presenting, without relying on a browser's summarized view.

Learning what's actually inside an X.509 certificate

See the real fields behind the padlock icon, decoded from the raw ASN.1 structure.

Auditing a certificate before deploying it

Double-check key size, algorithm, and validity window before putting a certificate into production.

Deep dive

About SSL/TLS Certificate Decoder

An X.509 certificate is encoded in ASN.1 DER — a compact, self-describing binary format that predates JSON or XML by decades but works on the same basic principle: every value is tagged with its type and length before its content. Reading one by hand means walking that tag-length-value structure recursively, which is exactly what this tool's parser does, decoding SEQUENCE, SET, INTEGER, OBJECT IDENTIFIER, BIT STRING, and time types directly from the raw bytes.

Rather than treating certificate decoding as a black box, this was built and verified from first principles: a self-signed test certificate was generated with OpenSSL, and this parser's output — subject, issuer, serial number, validity dates, RSA key size, and Subject Alternative Names — was checked field-by-field against Node.js's built-in crypto.X509Certificate parser, the same certificate-parsing engine Node uses internally. Separate EC (P-256) and expired-certificate test cases were checked the same way, confirming both key types and expiry detection work correctly.

It reads both RSA and EC (elliptic curve) public keys, correctly computing RSA modulus bit-length and identifying named EC curves like P-256, and decodes the extensions block, including a proper GeneralNames parser for Subject Alternative Names (covering DNS names, IP addresses, email addresses, and URIs), Basic Constraints, and Key Usage flags.

This tool intentionally stays in its lane: it decodes the certificate's own structure and dates, but doesn't check revocation status (CRL/OCSP) or validate the signature against a trusted root certificate authority, both of which require network access this tool deliberately doesn't use. Everything it does show, it computes entirely from the bytes you paste in, locally in your browser.

Compare

SSL/TLS Certificate Decoder vs. other options

How Open Tools Library compares to desktop software and other online tools.

FeatureOpen Tools LibraryDesktop softwareOther online tools
PriceFree, unlimitedopenssl CLI (free, but manual)Often free with upload required
Certificate privacyNever leaves your deviceStays localUploaded to a server
InterfaceReadable, structured fieldsRaw text output, manual readingVaries
EC key supportYes, with curve identificationYes, via flagsInconsistent
Verified correctnessChecked against Node.js's own parserMature, trustedUsually unknown
InstallationNoneRequiredNone
Pro tips

Pro tips

  • Paste the complete PEM block, including the -----BEGIN CERTIFICATE----- and -----END CERTIFICATE----- lines — the parser looks for those markers.
  • This decodes structure and dates only — it doesn't check revocation (CRL/OCSP) or validate trust against a certificate authority, since both require network access.
  • A certificate can be date-valid and still be self-signed or untrusted — check the self-signed badge and issuer field, not just the expiry status.
  • If a certificate chain (multiple PEM blocks) is pasted, only the first certificate is decoded.
Under the hood

Technical specs

Input format
PEM-encoded X.509 certificate
ASN.1 types handled
INTEGER, OID, SEQUENCE, SET, BIT STRING, OCTET STRING, UTCTime, GeneralizedTime, and more
Key types
RSA (any modulus size), EC (P-256, P-384, P-521)
Extensions decoded
Subject Alternative Name, Basic Constraints, Key Usage
Verification method
Cross-checked field-by-field against Node.js's crypto.X509Certificate
Processing location
100% local, in your browser

Privacy & security

A certificate you're inspecting might belong to internal infrastructure not meant for public eyes, even though certificates themselves — unlike private keys — aren't inherently secret.

Certificates are parsed entirely locally — never uploaded, never seen by a server.

This tool never processes private keys, only public certificates, by design.

No logging, no storage — nothing is retained after you close the tab.

Equally private whether you're inspecting a public website's certificate or an internal service's.

FAQ

Frequently asked questions

Is my certificate uploaded anywhere?

No. It's parsed entirely in your browser — nothing is ever transmitted.

Can this decode a private key?

No — this tool only decodes public certificates, never private keys, by design.

Does this tell me if a certificate is trusted?

No. It decodes the certificate's own fields and dates, but doesn't validate its signature against a trusted root or check revocation status — both require network access this tool intentionally avoids.

Can it decode a full certificate chain?

Only the first certificate in a pasted chain is decoded — paste one certificate at a time for chain inspection.

What key types are supported?

RSA (any modulus size) and EC (with named-curve identification for P-256, P-384, and P-521).

Stuck?

Troubleshooting

It says this can't be parsed as a certificate

Make sure the full PEM block is pasted, including the BEGIN/END CERTIFICATE lines — a partial paste or a private key pasted by mistake won't parse as a certificate.

An extension only shows a byte count, not details

This parser has specific decoders for the most common extensions (SAN, Basic Constraints, Key Usage) — less common extensions still show their raw size so you know they're present, even without a specific interpretation.

An EC certificate shows no curve name

This means the certificate uses a curve OID this parser doesn't have a name mapping for — the key size may still be inferred where possible.

The dates look off by a few hours from what I expected

All dates are decoded and displayed in UTC, per the certificate's own encoding — convert to your local time zone if comparing against a locally-displayed date.

Ready to use SSL/TLS Certificate Decoder?

Free, private, and ready right now — no signup required.

Scroll to SSL/TLS Certificate Decoder