Security · Developer tools
PGP key fingerprint calculator.
Paste an armored PGP public key and get the same fingerprint and key ID that gpg --fingerprint prints, plus the algorithm, creation time and user IDs.
The rule: a v4 fingerprint is SHA-1 over 0x99, the 2-byte length, then the primary key packet body; the key ID is its last 64 bits. A v6 fingerprint is SHA2-256 over 0x9B, the 4-byte length, then the packet body; its key ID is the first 64 bits.
How to calculate a PGP key fingerprint
- Paste the whole armored public key, from the BEGIN line to the END line.
- Press Calculate.
- Compare the fingerprint and key ID with the values the key owner published or that gpg --fingerprint prints.
Verifying a key before you trust it
A fingerprint is a hash of the primary public key, so two keys with the same fingerprint are the same key. Checking it against a value you got from a separate, trustworthy channel, such as the owner's website, a business card or a voice call, confirms you have the right key and not a lookalike. The calculator also shows the key algorithm, the creation time and the user IDs attached to the key.
It works by removing the armor, decoding the base64 body, checking the optional CRC-24 checksum, walking the OpenPGP packet headers and hashing the first public-key packet. Subkeys and signatures do not change the fingerprint. Only paste public keys; never paste a private key into any web page.
Computed locally
The calculator runs in your browser, inside an isolated frame on this page that has no network access. Your file is read and written back by your own device, so it is not uploaded to TNAADO or anyone else, and nothing is stored. The advertising on this page sits outside the frame and cannot see what you choose. Keys are processed in memory and are not sent anywhere.
- Compare every character of the fingerprint, or at least several groups at each end.
- A matching fingerprint proves identity of the key only, not of the person using it.
How a PGP key fingerprint is made
An ASCII-armored block is base64 of a stream of OpenPGP packets, optionally followed by a CRC-24 line that starts with =. The first Public-Key packet (tag 6) is the primary key, and the fingerprint is a hash of that packet alone. Subkeys and signatures do not change it.
- Strip the armor headers, base64-decode the body, and check the optional CRC-24 (initial value 0xB704CE, generator 0x864CFB).
- Walk the packet headers (old or new format) to find the first Public-Key packet, and read the User ID packets that follow it.
- Version 4 key: hash the byte
0x99, the 2-byte big-endian packet length and the packet body with SHA-1. The 160-bit result is the fingerprint and its low 64 bits are the key ID. - Version 6 key: hash the byte
0x9B, the 4-byte big-endian packet length and the packet body with SHA2-256. The 256-bit result is the fingerprint and its high 64 bits are the key ID. - The packet body also holds the version, the creation time (seconds since 1970-01-01 UTC) and the public-key algorithm id, which this tool shows by name.
To compare with your own machine, run gpg --fingerprint --keyid-format long you@example.com; it groups a v4 fingerprint as ten blocks of four hex digits. Version 3 keys (MD5 fingerprint) are deprecated and not supported. The v4 method is checked against GnuPG output for Ed25519 and RSA keys, and the v6 method against the sample certificate in RFC 9580 Appendix A.3. Sources: RFC 4880 section 12.2 and RFC 9580 section 5.5.4; armor checksum in RFC 9580 section 6.1.
Format and fingerprint only — not a trust check
This tool parses the key packet and computes hashes entirely in your browser. It cannot tell you whether a key belongs to the person it names, is signed by anyone, or has been revoked or expired. Compare the fingerprint with one you got from the owner over a separate channel. Nothing you paste is transmitted, stored, or logged. Do not paste private keys.
What a PGP fingerprint is for
An OpenPGP public key is a long block of text. Nobody compares two of them character by character, so people compare a short hash of the key instead: its fingerprint. If you receive someone's public key by email or download it from a website, the safe way to confirm it is genuine is to check its fingerprint against a copy you got by another route, such as in person, on a business card, or read out over a call. This tool computes the fingerprint from the armored key itself, so you can confirm it matches what gpg --fingerprint prints or what the owner published, without installing anything or sending the key anywhere.
Fingerprint, long key ID and short ID are different things
- Fingerprint: the full hash of the primary key packet. For a version 4 key it is SHA-1, 160 bits, usually shown as 40 hex characters. For a version 6 key it is SHA2-256, 256 bits, shown as 64 hex characters.
- Key ID: a 64-bit slice of the fingerprint, 16 hex characters. RFC 4880 defines the version 4 Key ID as the low-order 64 bits of the fingerprint. In RFC 9580 a version 6 Key ID is the first 64 bits.
- Because a Key ID is only 64 bits, treat it as a label for finding a key, not as proof that a key is the one you wanted. Compare the whole fingerprint when you are verifying a key.
What goes into the hash, and what does not
The fingerprint covers the primary public-key packet only: its version, its creation time, its algorithm and its public key material. For version 4 the hashed bytes are 0x99, a two-byte length and the packet body. For version 6 they are 0x9B, a four-byte length and the packet body. Because nothing else is hashed, the fingerprint does not change when the key owner adds or removes a user ID, adds a subkey, extends the expiry date or collects new signatures. It does change if the creation time or key material differs, which is why you cannot recompute a different fingerprint for the same key by editing text around it.
Worked example
Run gpg --armor --export you@example.com to print your public key, paste the block, and press Calculate. If the key is a version 4 key, the result is a 40-character fingerprint and the Key ID is the last 16 characters of it; the tool reports which key version it found. Run gpg --fingerprint you@example.com in a terminal and the two values match. The tool also lists the algorithm, the creation time and each user ID. The tool also reports whether the armor's optional CRC-24 checksum line matches, which helps spot text that was cut or altered in copying.
How to verify someone else's key
- Download or copy their armored public key.
- Paste it here and note the fingerprint.
- Get the owner's fingerprint through a separate channel you trust and compare all of the characters, not just the first and last groups.
- Only then import the key and decide whether to sign it.
Common mistakes
- Pasting a private key block. This tool only needs the public key, and you should never paste a private key into any web page.
- Comparing only the Key ID or the last 8 characters.
- Reading the fingerprint from the same web page that supplied the key, which proves nothing if that page was tampered with.
- Pasting a key that contains several keys. The fingerprint is for the first primary key in the block.
Related tools: the SSH Key Fingerprint Calculator for OpenSSH keys and the SHA-1 hash generator. Pasting the key text into a hash generator will not reproduce a fingerprint, because the hash covers a specific binary packet.
Common mix-ups
-
Often assumedThe 16-hex-digit key ID is the key's fingerprint.
What the source saysRFC 9580 defines a version 4 key ID as only the low-order 64 bits of the 160-bit fingerprint. The fingerprint is the full hash, so compare that when checking a key. [1]
-
Often assumedEvery OpenPGP fingerprint is a 40-digit SHA-1 hash.
What the source saysThat is true for version 4 keys. RFC 9580 gives version 6 keys a 256-bit SHA-256 fingerprint, and version 3 keys an MD5 one that the RFC calls deprecated. [1]
-
Often assumedAdding a new user ID or subkey to my key changes its fingerprint.
What the source saysA version 4 fingerprint is the SHA-1 hash of the primary Public Key packet alone, so adding a user ID or subkey, which are separate packets, does not change it. [1]
Checked against these sources on .
Frequently asked questions
What is a PGP key fingerprint?
It is a hash of the primary public key packet that uniquely identifies the key. For a version 4 key it is a 160-bit SHA-1 value, normally written as 40 hex characters. You compare it with a trusted copy to confirm a key is genuine.
How do I find the fingerprint of a PGP public key?
Run gpg --fingerprint on the key, or paste the armored public key into this tool. Both calculate the same value from the primary key packet. The tool also shows the key ID, algorithm, creation time and user IDs.
What is the difference between the fingerprint and the key ID?
The key ID is a 64-bit portion of the fingerprint. For a version 4 key it is the low-order 64 bits, the last 16 hex characters. Because it is much shorter, use it to find a key and use the full fingerprint to verify one.
Does the fingerprint change when I add a subkey or a user ID?
No. Only the primary public-key packet is hashed. Adding user IDs, subkeys, signatures or a new expiry date leaves the fingerprint unchanged.
What is a version 6 key fingerprint?
Version 6 keys, defined in RFC 9580, use SHA2-256 over a different prefix (0x9B and a four-byte length) instead of SHA-1. The fingerprint is 256 bits, and the key ID is its first 64 bits.
Why does my fingerprint not match gpg?
Check that you pasted the whole block from the BEGIN line to the END line, that it is a public key, and that it is the same key. If the block holds several keys, the tool uses the first primary key. Also compare against the primary key fingerprint, not a subkey's.
Is it safe to paste my public key here?
Yes for public keys: the calculation runs in your browser and nothing is sent. Do not paste a private key block into any web page, including this one.
Sources
- RFC 4880: OpenPGP Message Format, section 12.2: version 4 fingerprint: 0x99, two-octet length, key packet; Key ID is the low-order 64 bits (retrieved 2026-10).
- RFC 9580: OpenPGP, section 5.5.4: version 6 fingerprint: SHA2-256 with 0x9B and a four-octet length; Key ID is the first 64 bits (retrieved 2026-10).