Hash Algorithms

Name: Hash Algorithms
Creator: staticdata.dev
License: https://opensource.org/licenses/MIT

A curated reference of 36 widely-used hash algorithms spanning cryptographic standards (MD, SHA-1, SHA-2, SHA-3, BLAKE2/3, Whirlpool, RIPEMD) and non-cryptographic/checksum functions (CRC, FNV, MurmurHash, SipHash, xxHash, Adler-32). Each entry records the digest output size in bits, the internal compression block size where applicable, the algorithm family, the year it was published or first specified, and whether it is currently considered cryptographically secure.

v1.0.0 MIT 36 records Updated 2026-10-05 stable Source: NIST FIPS 180-4 (SHA family), NIST FIPS 202 (SHA-3 / Keccak), BLAKE2 specification, BLAKE3 specification

Quick fetch

Stable URL. CORS-enabled. No auth.

bash

curl https://staticdata.dev/v1/hash-algorithms.json

Or use as a typed import: import { hashAlgorithms } from "https://staticdata.dev/v1/hash-algorithms.ts"

Formats

JSON 5.0 KB

/v1/hash-algorithms.json

Open

min: 3.5 KB · /v1/hash-algorithms.min.json
CSV 1.3 KB

/v1/hash-algorithms.csv

Open
TypeScript 5.2 KB

/v1/hash-algorithms.ts

export const hashAlgorithms

type HashAlgorithm = (typeof hashAlgorithms)[number]

Open

Schema

Each record in the dataset has the following shape.

Schema
Field	Type	Description	Example
name	string	Algorithm name including variant if applicable	SHA-256
outputBits	number	Digest output size in bits	256
blockBits	number \| null	Internal compression block size in bits; null for non-block-based designs	512
family	string	Algorithm family or design lineage	SHA-2
year	number \| null	Year the algorithm was first published or standardised	2001
secure	boolean	Whether the algorithm is currently considered cryptographically secure	true

Preview

First 10 records.

Data preview
name	outputBits	blockBits	family	year	secure
Adler-32	32		Checksum	1995	false
BLAKE2b	512	1024	BLAKE	2012	true
BLAKE2s	256	512	BLAKE	2012	true
BLAKE3	256	512	BLAKE	2020	true
CRC-32	32		CRC	1975	false
CRC-64	64		CRC		false
FNV-1a (32-bit)	32		FNV	1991	false
FNV-1a (64-bit)	64		FNV	1991	false
Keccak-256	256	1088	SHA-3	2012	true
MD4	128	512	MD	1990	false

Showing 10 of 36. View full data: JSON · CSV

Fetch examples

Drop-in snippets in five languages.

curl

curl -sSL https://staticdata.dev/v1/hash-algorithms.json | jq '.[0]'

JavaScript

import type { HashAlgorithm } from "https://staticdata.dev/v1/hash-algorithms.ts";

const res = await fetch("https://staticdata.dev/v1/hash-algorithms.min.json");
if (!res.ok) throw new Error(`Fetch failed: ${res.status}`);
const hashAlgorithms: HashAlgorithm[] = await res.json();
console.log(hashAlgorithms[0]);

Python

import urllib.request, json

with urllib.request.urlopen("https://staticdata.dev/v1/hash-algorithms.min.json") as r:
    hashAlgorithms = json.load(r)

print(hashAlgorithms[0])

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	resp, err := http.Get("https://staticdata.dev/v1/hash-algorithms.min.json")
	if err != nil { panic(err) }
	defer resp.Body.Close()

	var data []map[string]any
	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
		panic(err)
	}
	fmt.Println(data[0])
}

Rust

use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let body = ureq::get("https://staticdata.dev/v1/hash-algorithms.min.json").call()?.into_string()?;
    let data: Vec<Value> = serde_json::from_str(&body)?;
    println!("{:?}", data.first());
    Ok(())
}

Sources and methodology

This dataset covers 36 hash algorithms across two broad categories: cryptographic hash functions intended for security-sensitive applications, and non-cryptographic hash/checksum functions optimised for speed and data-integrity checks. The cryptographic group includes the complete SHA-2 family (SHA-224/256/384/512 and the truncated SHA-512/224 and SHA-512/256 variants standardised in FIPS 180-4), all four SHA-3 fixed-output variants and both SHAKE XOFs (FIPS 202), BLAKE2b/BLAKE2s/BLAKE3, the full RIPEMD family, Whirlpool, and the now-broken MD4/MD5 and SHA-1. Non-cryptographic entries include CRC-32/64, Adler-32, FNV-1a (32- and 64-bit), MurmurHash3, SipHash-2-4, and xxHash (32-bit, 64-bit, and xxHash3 variants).

The secure field reflects broad consensus as of October 2026 on whether an algorithm is suitable as a general-purpose cryptographic hash today: algorithms with practical collision attacks (MD4, MD5, SHA-1), the RIPEMD variants (RIPEMD-128 has known weaknesses; RIPEMD-160 has no practical collision attack but only 80-bit collision resistance, below current recommendations; RIPEMD-256/320 offer no more security than RIPEMD-128/160), and functions that are not cryptographic hashes at all (CRC, FNV, MurmurHash, xxHash, Adler-32) are marked false. SipHash is a secure keyed PRF/MAC, but it is not a general-purpose unkeyed hash, so it is also false. The blockBits field is null for streaming or tree-based designs (FNV, CRC, MurmurHash, SipHash, xxHash, Adler-32) that do not operate on fixed-size compression blocks in the Merkle–Damgård sense. For BLAKE3 and the SHAKE XOFs, the output length is variable; the outputBits values listed reflect the standard or minimum security-level digest sizes. Keccak-256 is included separately from SHA3-256 because the two differ in padding (Ethereum and other systems use the original Keccak submission, not the NIST-standardised SHA3-256).

Versioning

URLs under /v1/ are stable: field names and types will not change in a way that breaks consumers. Values can be corrected or records added when the upstream source changes; schema-incompatible updates ship under a new version path. See the hash-algorithms changelog for this dataset's history.