ForHosting KIT · Developer Utilities

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.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

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.

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.

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.

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.

POSThttps://api.kit.forhosting.com/security/ssh-key-fingerprint-format

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.

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"}'
{
  "hash_bytes": [
    222,
    173,
    190,
    239,
    0,
    1,
    127,
    128
  ],
  "format": "hex-colon"
}
{
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_items128
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →