MurmurHash3 hash calculator
Type Hello, world! and get c0363e43: the MurmurHash3 x86 32-bit hash of its 13 bytes with the default seed 0. Use it to check hash tables, shard keys or test values, never to protect passwords. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- Hello, world!
- Result
- c0363e43
- Murmur3
- c0363e43
- Hex
- c0363e43
- Seed
- 0
MurmurHash3 is a fast non-cryptographic hash designed by Austin Appleby for hash tables, sharding keys, bloom filters, and content fingerprints where speed and good distribution matter more than collision resistance against an adversary. The widely used x86 32-bit variant mixes the message in four-byte blocks with published constants, folds a short tail, and finishes with a length-aware final mix, producing a single unsigned thirty-two bit word.
What MurmurHash3 x86 32-bit computes and why the seed matters
MurmurHash3 x86 32-bit treats every message as an ordered sequence of octets. The hash register is initialised to the caller-supplied seed, which defaults to zero when omitted.
The stream is processed in four-byte little-endian blocks: each block is multiplied by the constant c c nine e two d five one, rotated left fifteen bits, multiplied by one b eight seven three five nine three, then mixed into the running hash with a left rotate of thirteen bits and a multiply-add using five and e six five four six b six four.
Any remaining one to three tail bytes are mixed with the same constants before a finalisation step that xors the total length, applies two avalanche multiplies with eight five e b c a six b and c two b two a e three five, and interleaves right shifts. Well-known checks include the ASCII string foo at seed zero yielding f six a five c four two zero, and Hello comma space world exclamation at seed zero yielding c zero three six three e four three.
Changing the seed changes the digest for the same bytes, which is intentional for multi-hash sets and partitioned maps. Because MurmurHash3 is not collision-resistant against a motivated attacker, not keyed for secrecy, and not suitable for passwords or signatures, treat it as a fast content identifier or hash-table mixer—not as proof of authenticity. Prefer SHA-family digests when the search intent is cryptographic hashing rather than a MurmurHash3 non-cryptographic hash.
Where a MurmurHash3 hash is useful
Language runtime authors and systems students use a MurmurHash3 hash calculator to verify hand-computed block mixes and finalisation steps against published constants without writing a full avalanche loop in every language. Teaching platforms and LMS plugins need a deterministic oracle that rejects empty input and bad seeds instead of wrapping silently, so auto-graders can distinguish configuration mistakes from real digests. Content sites ranking for MurmurHash3 hash or murmurhash3 calculator benefit from a live tool whose free path matches the paid automation path byte-for-byte on the same pure module.
Validation failures never consume balance after rejection. Pair with FNV-1, Adler-32, CRC, or cryptographic hash landings only when the search intent moves beyond MurmurHash3—keep this page focused on MurmurHash3 x86 32-bit so SEO intent stays sharp and does not cannibalize related checksum or digest landings.
What you can do with it
Hash-table and sharding keys
Generate stable MurmurHash3-x86-32 hex keys for short strings used as map buckets, shard ids, or feature-flag partitions, with an optional seed for multi-hash layouts.
Classroom MurmurHash3 demos
Teachers show classic foo and Hello, world! check values at seed zero and let students recompute other short strings without installing a native module.
FAQ
What seed values are allowed?
Seed must be an integer from 0 to 4294967295 inclusive. Omit it to use 0.
What happens if the text is empty?
A non-empty string is required; empty input is not treated as a successful hash.
Is the MurmurHash3 calculator free?
The browser tool runs free on your device.
Is MurmurHash3 a cryptographic hash?
No. MurmurHash3 is a fast non-cryptographic hash for hash tables and content keys. Use SHA-256 or similar when you need collision resistance or authentication.
Does changing the seed change the MurmurHash3 hash?
Yes. The same text gives a different hash for each seed, and that is intentional: it lets you build several independent hashes for a bloom filter or a partitioned map. Leave the seed empty to use 0.
Related tools
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/enc/murmur3 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello, world!"}'const res = await fetch("https://api.kit.forhosting.com/enc/murmur3", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello, world!"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/murmur3",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello, world!"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/murmur3", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello, world!"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello, world!"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/murmur3", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "Hello, world!"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.murmur3",
"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.
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. |
Technical notes
Empty input and invalid seeds are rejected with invalid_input so callers never confuse a missing field or a bad seed with a real hash.
Input contract, seed validation, and the JSON response shape
When seed is omitted, the algorithm uses zero. The string is encoded as UTF-8 before the Murmur loop, so multi-byte characters contribute every code unit byte exactly as a language runtime would if it hashed the same UTF-8 stream. Pin both a success path and an invalid-seed error in continuous integration so accidental constant or rotation changes cannot ship unnoticed. Optional null fields are omitted rather than emitted as null, matching the declarative renderer contract for clean web forms. POST a JSON body with a required string field named text: any non-empty sequence of characters you want to hash. Aliases input, value, s, data, message, and payload are accepted for the same field so SDK stubs and form posts stay flexible. Optional field seed is an integer from zero through four billion two hundred ninety-four million nine hundred sixty-seven thousand two hundred ninety-five inclusive (the full unsigned thirty-two bit range); aliases salt and init are accepted. Missing text, a non-string value, or an empty string all fail with invalid_input and a clear message that a non-empty string is required; those failures are not billed on the prepaid API. An invalid seed—non-numeric, fractional, boolean, negative, or larger than two to the thirty-two minus one—also fails with invalid_input and an explicit invalid seed message so operators can fix configuration without silent modular wrap. On success the body includes result, murmur3, and hex all set to the same eight-digit lowercase hexadecimal digest; seed set to the value used; algorithm fixed at MurmurHash3-x86-32; input_bytes equal to the UTF-8 length; text echoing the input; and message summarizing the byte count, seed, and hex result.
Where a MurmurHash3 hash API earns its keep and how pricing works
Call the free in-browser tool for one-off checks; call the prepaid KIT API from backends, serverless functions, and SDKs when you need a stable contract under balance at $0.002 per successful item. Keep payloads to ordinary text sizes appropriate for a Worker isolate item call; this tool is for short strings and protocol snippets, not multi-megabyte binary blobs.
Integration use cases
CI fixtures for non-crypto hash helpers
Pipelines pin deterministic MurmurHash3 hex outputs and the invalid-seed error so accidental constant, rotation, or wrap changes fail fast.
Technical questions
How do I compute a MurmurHash3 hash of text?
Send JSON with a non-empty string field text and optional seed (uint32, default 0). The API UTF-8-encodes the string, runs MurmurHash3 x86 32-bit, and returns the hash as eight lowercase hex digits in result, murmur3, and hex.