BIP-39 mnemonic encoder
Sixteen zero bytes of entropy become “abandon” eleven times followed by “about”: BIP-39 turns 128 to 256 bits into 12 to 24 English words with a SHA-256 checksum, and recovers the entropy only while that checksum matches. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- 00000000000000000000000000000000
- Calculation mode
- Encode
- Input
- 00000000000000000000000000000000
- Entropy hex
- 00000000000000000000000000000000
- Word count
- 12
- Entropy bits
- 128
BIP-39 is the industry standard that turns binary wallet entropy into a human-readable mnemonic of twelve to twenty-four English words, then recovers the same entropy only when the embedded SHA-256 checksum bits still match. Failed validation is not billed; successful calls cost the published base price per item.
How BIP-39 maps entropy to words and back
BIP-39 starts from raw entropy of one hundred twenty-eight, one hundred sixty, one hundred ninety-two, two hundred twenty-four, or two hundred fifty-six bits. The specification takes the first ENT divided by thirty-two bits of the SHA-256 digest of those entropy bytes and appends them as a checksum, producing a bit string whose length is always a multiple of eleven. Each eleven-bit group is an index into a fixed list of two thousand forty-eight English words ordered alphabetically from abandon to zoo.
Twelve words correspond to one hundred twenty-eight bits of entropy plus four checksum bits; fifteen, eighteen, twenty-one, and twenty-four words scale the same way up to two hundred fifty-six bits plus eight checksum bits. Encoding is therefore fully determined by the entropy bytes and the word list: there is no salt, no language choice in this capability beyond English, and no private key derivation step.
Decoding reverses the map: split the phrase on whitespace, look up each word, rebuild the bit string, peel off the trailing checksum window, and verify that those bits equal the leading bits of SHA-256 of the recovered entropy. If any word is unknown, the word count is not one of the five legal lengths, or the checksum bits disagree, the operation fails.
That fail-closed design is why wallets prefer mnemonics over raw hex for human backup: a single wrong word almost always fails the checksum instead of unlocking a different wallet. This landing targets people searching for a BIP-39 mnemonic encoder, entropy to seed phrase converter, or mnemonic checksum checker; it does not run PBKDF2 seed derivation, does not generate random entropy, and does not support non-English word lists.
Practical vectors, testing tips, and how this differs from seed derivation
Prefer decode when a human pasted a phrase and you must recover entropy only if the checksum is intact. Classic all-zero sixteen-byte entropy encodes to eleven abandon words followed by about; all-one-bits sixteen-byte entropy encodes to eleven zoo words followed by wrong. Round-trip both in CI: encode, assert the mnemonic, decode, assert the original hex.
Use a separate BIP-32 or PBKDF2 tool if you need the sixty-four-byte seed from mnemonic plus optional passphrase—that step is intentionally out of scope here so the SEO landing stays focused on encode and decode with checksum verification. When teaching, show students that two mnemonics differing by one word almost never share a valid checksum, which is the property that makes handwritten backups safer than raw hex dumps.
Pair this capability with Base58Check or hex utilities when your pipeline also formats addresses or private keys after the seed is derived elsewhere.
What you can do with it
Teaching checksummed seed phrases
Show classic all-zero and all-ones vectors, then flip one word so learners see why BIP-39 fails closed instead of opening the wrong wallet.
FAQ
How do I convert entropy hex to a BIP-39 mnemonic?
Send mode encode (default) with text set to 32, 40, 48, 56, or 64 hex digits (16–32 bytes).
How do I decode a mnemonic back to entropy?
Send mode decode with text set to a 12, 15, 18, 21, or 24 word English BIP-39 phrase.
What happens if the checksum is wrong?
Wrong or mistyped phrases are never billed and never return fake entropy.
Which word list and lengths are supported?
Only the official BIP-39 English list of 2048 words. Entropy must be 128, 160, 192, 224, or 256 bits (word counts 12, 15, 18, 21, or 24).
Does this tool create random entropy or a wallet seed?
No. It only converts entropy you provide into words and back, checking the checksum. It does not generate random entropy, does not derive the wallet seed from the phrase and an optional passphrase, and works only with the English word list.
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/bip39 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"00000000000000000000000000000000"}'const res = await fetch("https://api.kit.forhosting.com/enc/bip39", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "00000000000000000000000000000000"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/bip39",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "00000000000000000000000000000000"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/bip39", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"00000000000000000000000000000000"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"00000000000000000000000000000000"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/bip39", 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": "00000000000000000000000000000000"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.bip39",
"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
This BIP-39 mnemonic encoder accepts entropy as hexadecimal (sixteen, twenty, twenty-four, twenty-eight, or thirty-two bytes) and returns the official English word list phrase; in decode mode it maps each word back to an eleven-bit index, splits entropy from checksum, recomputes SHA-256 of the entropy, and returns invalid_input when the checksum bits disagree.
Input contract, response fields, and error behaviour
POST a JSON body with a required string field text (aliases include input, value, data, entropy, and mnemonic) and an optional mode of encode or decode (default encode). In encode mode, text must be hexadecimal entropy: after stripping whitespace, colons, underscores, and hyphens, the string must have even length and decode to exactly sixteen, twenty, twenty-four, twenty-eight, or thirty-two bytes. Odd length, non-hex characters, or any other byte count return invalid_input naming the problem. On success the response echoes the normalized lowercase hex as input and entropy_hex, sets result and mnemonic to the same space-separated English phrase, and reports word_count, entropy_bits, checksum_bits, wordlist english, standard BIP-39, and a short English message. In decode mode, text is a mnemonic: words are lowercased and split on spaces, commas, or semicolons; each must appear in the official English list; the count must be twelve, fifteen, eighteen, twenty-one, or twenty-four. On success result and entropy_hex hold the recovered lowercase hex, mnemonic is the normalized phrase, checksum_valid is true, and the same size fields are included. Missing text, unknown mode, empty mnemonic, wrong word count, and unknown words also return invalid_input and are never charged.
Practical vectors, testing tips, and how this differs from seed derivation
Deliberately change the last word of a valid twelve-word phrase to abandon and assert invalid_input with a checksum mismatch match string. Keep entropy sources offline and high quality when building real wallets; this API never samples randomness and never stores your bytes. Failed tasks do not consume prepaid balance, which keeps exploratory scripts cheap when you fuzz bad phrases.
Integration use cases
Wallet fixture and CI checks
Encode known entropy hex into BIP-39 phrases for golden tests, then decode and assert checksum_valid so wallet libraries cannot silently drift from the BIP.
Paste-safe mnemonic verification
Decode user-supplied seed phrases and reject mistyped words or broken checksums with invalid_input before any seed derivation step runs.
Technical questions
What does the BIP-39 mnemonic encoder cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.