Format an SSH key fingerprint as colon hex or Base64
An SSH fingerprint is a compact display of hash bytes that helps people compare a public key with a trusted value.
Run — free
This formatter takes the hash bytes you already calculated and renders them consistently as lowercase, colon-separated hexadecimal or unpadded Base64. It does not parse a key, choose a hash algorithm, or calculate a digest. By keeping hashing separate from presentation, it gives scripts, administration tools, documentation generators, and test suites a precise way to produce the fingerprint notation they require without changing the underlying bytes.
Start with the raw digest, not a key file
This capability accepts the bytes of a hash that has already been computed from an SSH public key. Supply those bytes in their original order as integers between 0 and 255. For example, a digest beginning with byte values 222, 173, 190, and 239 begins with <code>de:ad:be:ef</code> in the hexadecimal display. The formatter deliberately does not accept an OpenSSH key line, a PEM block, a certificate, or text that merely looks like a digest. Those tasks involve parsing or hashing and should happen before formatting. This separation matters because a fingerprint renderer cannot safely infer which key encoding or digest algorithm produced an arbitrary string. It also makes the result easy to test: the same byte sequence always produces exactly the same characters. Preserve every byte, including leading zero bytes, because dropping one changes both the colon-hex and Base64 fingerprint. An empty array is rejected because it cannot represent a useful public-key digest, and the bounded input keeps accidental oversized payloads from masquerading as fingerprints.
Choose the display expected by the receiving system
Select <code>hex-colon</code> when a tool, inventory, or runbook expects two lowercase hexadecimal digits for each byte, separated by colons. Every byte keeps its full width, so zero is displayed as <code>00</code>, fifteen as <code>0f</code>, and 255 as <code>ff</code>. Select <code>base64</code> when the receiving system expects the compact alphabet commonly used for modern SSH fingerprint displays. The Base64 result is emitted without trailing equals-sign padding, which is conventional for displayed SSH fingerprints and avoids presentation-only characters that do not identify additional hash data. These choices only alter the representation; they never alter, reverse, truncate, or rehash the bytes. The response includes both <code>fingerprint</code> and <code>format</code>, allowing downstream code to retain the notation alongside the value. Format names are intentionally strict. A misspelling, unsupported label, or different casing returns an input error instead of silently choosing a default. That behavior prevents a plausible-looking fingerprint from being copied into a system that expects another notation.
Compare fingerprints safely and understand the boundary
Use the rendered value only after you know how the raw digest was obtained. A matching display is meaningful when both sides hashed the same canonical public-key bytes with the same digest algorithm. Formatting cannot prove that those conditions were met, and converting a value does not strengthen the digest or authenticate a host. When documenting a fingerprint, record the hash algorithm separately if the surrounding protocol or interface does not already identify it. When comparing values in automation, normalize both from their underlying bytes or require one explicit format rather than guessing from punctuation. This capability is useful at the presentation boundary: it provides stable output for terminal messages, deployment reports, host inventories, approval screens, and regression fixtures. It performs no network access and stores no keys or fingerprints. The browser version runs locally, while API automation costs $0.002 per request. Invalid byte values and unsupported formats fail clearly, so a broken upstream conversion cannot quietly become an authoritative-looking security identifier. Treat a mismatch as a reason to stop and verify the source through a trusted channel.
What you can do with it
Prepare a host verification prompt
Render a digest in the exact notation shown to an operator before they approve a newly provisioned SSH host.
Normalize inventory output
Give asset records a consistent fingerprint display even when upstream scanners return raw digest bytes.
Build deterministic test fixtures
Generate stable expected fingerprint strings for SSH tooling without relying on operating-system commands or locale settings.
FAQ
Does this calculate the hash of an SSH public key?
No. It only formats raw hash bytes that were calculated beforehand. Key parsing and digest calculation must occur upstream.
What does the Base64 format return?
It returns the standard Base64 alphabet without trailing equals-sign padding, preserving the original byte order.
Does the hexadecimal result preserve leading zeros?
Yes. Every byte is represented by exactly two lowercase hexadecimal digits and adjacent bytes are separated by colons.
Which byte values are valid?
Each item must be an integer from 0 through 255. The array must contain between one and 128 items.
What happens if I request another format?
The request fails with an invalid-input error. Only the explicit <code>hex-colon</code> and <code>base64</code> values are supported.
How much does API formatting cost?
Each API request costs $0.002. You can also run the same deterministic formatter in your browser.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/security/ssh-key-fingerprint-format \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hash_bytes":[222,173,190,239,0,1,127,128],"format":"hex-colon"}'const res = await fetch("https://api.kit.forhosting.com/security/ssh-key-fingerprint-format", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hash_bytes": [
222,
173,
190,
239,
0,
1,
127,
128
],
"format": "hex-colon"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/ssh-key-fingerprint-format",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hash_bytes": [
222,
173,
190,
239,
0,
1,
127,
128
],
"format": "hex-colon"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/ssh-key-fingerprint-format", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hash_bytes":[222,173,190,239,0,1,127,128],"format":"hex-colon"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hash_bytes":[222,173,190,239,0,1,127,128],"format":"hex-colon"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/ssh-key-fingerprint-format", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"hash_bytes": [
222,
173,
190,
239,
0,
1,
127,
128
],
"format": "hex-colon"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.ssh_key_fingerprint_format",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_items | 128 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |