Check that a private key belongs to an SSL certificate or CSR; the key is never uploaded
Runs in your browser. Nothing you type is sent anywhere. Checked against sources on 16 Nov 2026.Checked against the tool’s code on 18 November 2026. Figures read from their sources on 16 November 2026. What we collect
Paste a certificate and a private key and the first line says whether they match. In the example, the certificate for shop.example.com, its RSA 2048 key and its CSR all share the public key fingerprint 9E:3F:85:32, so they match; another RSA key gives 49:9A:D1:68 and does not. The key is compared in your browser, never uploaded.
| Pasted | Result | Public key SHA-256 (first bytes) |
|---|---|---|
| Certificate for shop.example.com + its key + its CSR | Match | 9E:3F:85:32 / 9E:3F:85:32 / 9E:3F:85:32 |
| Certificate for shop.example.com + another RSA key | No match | 9E:3F:85:32 / 49:9A:D1:68 |
| Root CA certificate + the leaf key | No match | 17:3F:7C:65 / 9E:3F:85:32 |
Nothing is uploaded: this runs in your browser.
Paste the certificate and the private key in one box, in any order, or open the files.
Add the CSR too if you have it; every key is compared with every certificate and request.
Read the first line: they match, or they do not match.
Compare the public key SHA-256 column: matching items share the same value.
A certificate is a signed statement about one public key. Only the private key made together with that public key can use the certificate, so a server given the wrong key refuses to start: nginx says "key values mismatch", Apache "private key does not match the certificate", IIS shows the certificate without a key. It happens after a renewal, when a new signing request was made with a new key but the old key file stayed on the server.
The check compares the public key inside each file. A certificate and a CSR carry it openly; a private key carries it too (the RSA modulus and exponent, or the EC point), or it is worked out from the key with your browser's WebCrypto. Equal public keys mean the files belong together.
| Question | Answer |
|---|---|
| Compares | Certificates, CSRs, public keys and private keys, every key against every other file |
| Key types | RSA, EC (P-256, P-384, P-521), Ed25519 and X25519 |
| Key formats | PKCS#8, PKCS#1 (BEGIN RSA PRIVATE KEY) and SEC1 (BEGIN EC PRIVATE KEY) |
| Encrypted keys | Not read: decrypt first with openssl pkey |
| Where it runs | In your browser; the private key is never uploaded or stored |
Checked on 16 November 2026 against RFC 5280, RFC 5958 and RFC 2986. Page last updated on 16 November 2026.
For RSA, compare openssl x509 -noout -modulus -in cert.pem | openssl sha256 with openssl rsa -noout -modulus -in key.pem | openssl sha256; equal hashes mean a match. EC keys need openssl pkey -pubout instead. Once the pair matches, the PEM to PFX converter packs them for Windows; to read a certificate's names and dates, use the certificate decoder.
Paste both into the box on this page, in any order. The first line answers: they match, or they do not. Behind it, the public key in the certificate is compared with the public key in the private key; equal keys mean a match. The private key never leaves your browser.
Nginx found a private key that does not belong to the certificate in ssl_certificate. Usually the certificate was renewed with a new signing request and a new key, while the old key file stayed in place. Paste both files here to confirm, then point ssl_certificate_key at the key that matches.
Paste the certificate and every candidate key together. Each key is compared with the certificate and the result lists every pairing, so the one that matches stands out. The table also shows a public key fingerprint per file: the certificate and its key share the same value.
Yes. Paste the CSR with the key, or all three files at once. A signing request holds the public key it was made for, so the check works before the certificate even exists. When a certificate authority reissues, pasting the new certificate with the old CSR shows whether the same key was kept.
The key is read and compared by code running in your browser; nothing is sent to a server, logged or stored, and closing the tab clears it. For keys that guard production systems, you can also run the OpenSSL modulus comparison on your own machine, which this page describes.
Yes: RSA, EC keys on P-256, P-384 and P-521, Ed25519 and X25519 are compared. When a PKCS#8 file leaves out its public key, your browser's WebCrypto works it out. Encrypted keys need decrypting first with openssl pkey, because the page never asks for a key's password.
Rates and rules change; check the source before you rely on a figure.
Still stuck? Ask about Certificate Key Matcher: Does the Private Key Match? and anybody who knows can answer. No account needed.
Same job, other tools: SSL Certificate Decoder – Decode a TLS certificate you already have and see every field a browser looks at · Webhook Signature Verifier – Check that a webhook body matches the signature header its sender attached · 2FA Code Generator – Get the current two-factor code from a setup key, without a phone · CSR Decoder – CSR decoder: see what a certificate signing request asks for before it goes to a CA.
On the related tools: JWT Decoder – Paste a token to read its header, payload and expiry.
On the same topic: PEM to PFX Converter: Make a .pfx / .p12 in Your Browser – PEM certificate and key to a password-protected .pfx (PKCS#12), key never uploaded · CSR Generator: Create a CSR and Private Key in Your Browser – Make a certificate signing request and its private key on your device, no upload.