Memorable names for hex digests.

Try it

GET any hex digest at /api/v1/hash/<hex>. The endpoint is open, deterministic, and CORS-enabled:

Response:

{
  "inputHash": "f3527e4ef32f9d8b59ead6b7b70a843c3da1c105",
  "hash": "canyon-jam-telescope-creek"
}

How it works

HumanHash maps any hexadecimal string to a short, pronounceable name in three steps:

1. Parse the hex input into a byte array.
2. Compress those bytes into N equal segments (N = 4 by default) and XOR the bytes inside each segment down to a single byte.
3. Map each resulting byte (0–255) to one entry in a curated 256-word list, then join with hyphens.

The output is fully deterministic — the same input always yields the same name — and the algorithm is stateless, with no database or randomness involved. Four words from a 256-word list give 256⁴ ≈ 4.3 billion combinations, which is roughly a 32-bit fingerprint: comfortable for human recognition of individual deploys or builds, but not a substitute for the underlying hash when collision-resistance matters.

API reference

Code examples

curl

curl https://humanhash.dev/api/v1/hash/f3527e4ef32f9d8b59ead6b7b70a843c3da1c105

JavaScript (fetch)

const hex = "f3527e4ef32f9d8b59ead6b7b70a843c3da1c105";
const res = await fetch(`https://humanhash.dev/api/v1/hash/${hex}`);
const { hash } = await res.json();
console.log(hash); // "canyon-jam-telescope-creek"

Python

import requests

hex_digest = "f3527e4ef32f9d8b59ead6b7b70a843c3da1c105"
r = requests.get(f"https://humanhash.dev/api/v1/hash/{hex_digest}")
print(r.json()["hash"])  # "canyon-jam-telescope-creek"

Go

resp, _ := http.Get("https://humanhash.dev/api/v1/hash/f3527e4ef32f9d8b59ead6b7b70a843c3da1c105")
defer resp.Body.Close()
var out struct{ InputHash, Hash string }
json.NewDecoder(resp.Body).Decode(&out)
fmt.Println(out.Hash) // "canyon-jam-telescope-creek"

UUID

UUIDs work too — strip the hyphens first:

curl https://humanhash.dev/api/v1/hash/550e8400e29b41d4a716446655440000
# => {"inputHash":"550e8400e29b41d4a716446655440000","hash":"vault-lift-onion-lilac"}

Example: GitHub Actions

A common pattern is to derive a memorable name from github.sha and use it alongside the SHA — for example, to tag a Docker image with both. This is exactly how we use HumanHash in our own production pipelines:

name: build

on:
  push:
    branches: ["main"]

env:
  IMAGE_NAME: "ghcr.io/your-org/your-app"

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Get human hash
        run: echo "HUMAN_HASH=$(curl -s "https://humanhash.dev/api/v1/hash/${{ github.sha }}" | jq -r '.hash')" >> "$GITHUB_ENV"

      - name: Build Docker image
        run: docker build . --tag ${{ env.IMAGE_NAME }}:${{ github.sha }} --tag ${{ env.IMAGE_NAME }}:${{ env.HUMAN_HASH }}

      - name: Log in to registry
        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin

      - name: Push image
        run: docker push --all-tags ${{ env.IMAGE_NAME }}

Every push gets two tags: the exact SHA for reproducibility, and a human-friendly name like swift-river-mellow-bolt that's actually usable in chat, dashboards, and standups. The jq binary is preinstalled on the GitHub-hosted ubuntu-latest runner, so no extra setup is needed.

Use cases

• Build & deploy names. Tag a CI build as swift-river-mellow-bolt instead of 7c4f9a2. Easier to refer to in standups, easier to find in chat history.
• Commit references in chat. Pasting a SHA into Slack gets ignored; pasting canyon-jam-telescope-creek gets read.
• Session and request IDs in logs. When grepping across services or saying an ID out loud on a call, words beat hex.
• Backup and snapshot names. Restoring vault-bronze-falcon-river is less terrifying than restoring b8f9c1d2…
• Fingerprint comparison. Comparing SSH or TLS fingerprints visually is much faster as four words than as 40 hex characters.
• Asset / version labels. Give your build artifacts, model checkpoints, or dataset snapshots a name humans can talk about.

Comparison with other identifier formats

HumanHash is unique in being a deterministic projection of an existing identifier — it does not replace your UUID or hash, it shadows it with a name humans can read. Pair the two.

Frequently asked questions

The 256-word vocabulary

Outputs are drawn from a curated list of 256 short, pronounceable English words, grouped into eight themed categories of 32. The list avoids ambiguous spellings, near-homophones, and words that read badly when chained.

About

HumanHash is operated by Pilvia Oy, a Finnish cloud company. We use it internally to label builds, deploys, and snapshots, and have opened it up because the algorithm is generally useful.

The humanhash concept originated as a small Python library by Zachary Voase. This implementation is an independent TypeScript rewrite running on Cloudflare Workers, with a curated wordlist of our own.