Codificador mnemônico BIP-39
Dezesseis bytes de entropia zerados viram “abandon” onze vezes seguido de “about”: o BIP-39 transforma de 128 a 256 bits em 12 a 24 palavras em inglês com um checksum SHA-256, e só recupera a entropia enquanto esse checksum confere. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Texto
- 00000000000000000000000000000000
- Modo de cálculo
- Encode
- Entrada
- 00000000000000000000000000000000
- Entropia em hex
- 00000000000000000000000000000000
- Contagem de palavras
- 12
- Bits de entropia
- 128
BIP-39 é o padrão da indústria que transforma a entropia binária de uma carteira em um mnemônico legível de doze a vinte e quatro palavras em inglês e recupera a mesma entropia somente quando os bits de checksum SHA-256 embutidos ainda coincidem. Validação falha não é cobrada; chamadas bem-sucedidas custam o preço base publicado por item.
Como o BIP-39 mapeia entropia para palavras e de volta
O BIP-39 parte de entropia bruta de cento e vinte e oito, cento e sessenta, cento e noventa e dois, duzentos e vinte e quatro ou duzentos e cinquenta e seis bits. A especificação toma os primeiros ENT divididos por trinta e dois bits do resumo SHA-256 desses bytes de entropia e os anexa como checksum, produzindo uma cadeia de bits cujo comprimento é sempre múltiplo de onze.
Cada grupo de onze bits é um índice em uma lista fixa de dois mil e quarenta e oito palavras em inglês ordenadas alfabeticamente de abandon a zoo. Doze palavras correspondem a cento e vinte e oito bits de entropia mais quatro bits de checksum; quinze, dezoito, vinte e uma e vinte e quatro palavras escalam da mesma forma até duzentos e cinquenta e seis bits mais oito bits de checksum.
A codificação fica, portanto, totalmente determinada pelos bytes de entropia e pela lista: não há sal, não há escolha de idioma nesta capacidade além do inglês e não há passo de derivação de chave privada. A decodificação inverte o mapa: divide a frase por espaços, busca cada palavra, reconstrói a cadeia de bits, separa a janela final de checksum e verifica se esses bits igualam os bits iniciais de SHA-256 da entropia recuperada.
Se alguma palavra for desconhecida, a contagem não for um dos cinco comprimentos legais ou os bits de checksum discordarem, a operação falha. Esse desenho de falha fechada é por que carteiras preferem mnemônicos ao hex bruto para backup humano: uma única palavra errada quase sempre falha o checksum em vez de desbloquear outra carteira.
Esta landing atende quem busca um codificador de mnemônicos BIP-39, um conversor de entropia em frase semente ou um verificador de checksum de mnemônico; não executa derivação de semente PBKDF2, não gera entropia aleatória e não suporta listas de palavras em outros idiomas.
Vetores práticos, dicas de teste e diferença da derivação de semente
Prefira decode quando uma pessoa colou uma frase e você deve recuperar a entropia somente se o checksum estiver intacto. A entropia clássica de dezesseis bytes tudo zero codifica em onze palavras abandon seguidas de about; a de dezesseis bytes com todos os bits em um codifica em onze zoo seguidas de wrong. Faça ida e volta no CI: codifique, afirme o mnemônico, decodifique e afirme o hex original.
Use uma ferramenta BIP-32 ou PBKDF2 separada se precisar da semente de sessenta e quatro bytes a partir do mnemônico mais frase secreta opcional — esse passo fica de propósito fora do escopo para a landing SEO focar em codificar e decodificar com verificação de checksum. Tarefas falhas não consomem saldo pré-pago, o que mantém baratos scripts exploratórios ao fuzzar frases ruins.
Ao ensinar, mostre aos alunos que dois mnemônicos que diferem em uma palavra quase nunca compartilham checksum válido, propriedade que torna backups manuscritos mais seguros que dumps hex brutos. Combine esta capacidade com utilitários Base58Check ou hex quando o pipeline também formatar endereços ou chaves privadas depois que a semente for derivada em outro lugar.
Casos de uso
Ensino de frases semente com checksum
Mostre os vetores clássicos tudo zero e tudo um; depois troque uma palavra para que o aluno veja por que o BIP-39 falha de forma fechada em vez de abrir outra carteira.
Perguntas frequentes
Como converter entropia hex em um mnemônico BIP-39?
Envie mode encode (padrão) com text em 32, 40, 48, 56 ou 64 dígitos hex (16–32 bytes).
Como decodificar um mnemônico de volta para entropia?
Envie mode decode com text em uma frase BIP-39 em inglês de 12, 15, 18, 21 ou 24 palavras.
O que acontece se o checksum estiver errado?
Frases erradas ou mal digitadas nunca são cobradas e nunca devolvem entropia falsa.
Quais listas de palavras e comprimentos são suportados?
Apenas a lista oficial BIP-39 em inglês com 2048 palavras. A entropia deve ser de 128, 160, 192, 224 ou 256 bits (contagens de 12, 15, 18, 21 ou 24 palavras).
Esta ferramenta gera entropia aleatória ou a semente de uma carteira?
Não. Ela só converte em palavras a entropia que você fornece, e de volta, conferindo o checksum. Não gera entropia aleatória, não deriva a semente da carteira a partir da frase e de uma senha opcional e só trabalha com a lista de palavras em inglês.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"text": "00000000000000000000000000000000"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.bip39",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Este codificador de mnemônicos BIP-39 aceita entropia em hexadecimal (dezesseis, vinte, vinte e quatro, vinte e oito ou trinta e dois bytes) e devolve a frase da lista oficial em inglês; no modo decode mapeia cada palavra para um índice de onze bits, separa entropia do checksum, recalcula SHA-256 da entropia e devolve invalid_input quando os bits de checksum não batem. O caminho gratuito do navegador e a API pré-paga compartilham o mesmo módulo parse puro, de modo que vetores dourados como entropia tudo zero produzindo onze palavras abandon seguidas de about comparam byte a byte entre ambientes.
Contrato de entrada, campos de resposta e comportamento de erro
No modo encode, text deve ser entropia hexadecimal: após remover espaços, dois-pontos, underscores e hífens, a string deve ter comprimento par e decodificar exatamente para dezesseis, vinte, vinte e quatro, vinte e oito ou trinta e dois bytes. No modo decode, text é um mnemônico: as palavras ficam em minúsculas e se dividem por espaços, vírgulas ou ponto e vírgula; cada uma deve constar da lista oficial em inglês; a contagem deve ser doze, quinze, dezoito, vinte e uma ou vinte e quatro. Envie um corpo JSON com o campo de string obrigatório text (aliases: input, value, data, entropy e mnemonic) e um mode opcional encode ou decode (padrão encode). Comprimento ímpar, caracteres não hex ou outra contagem de bytes devolvem invalid_input nomeando o problema. Em sucesso a resposta ecoa o hex minúsculo normalizado como input e entropy_hex, define result e mnemonic com a mesma frase em inglês separada por espaços e informa word_count, entropy_bits, checksum_bits, wordlist english, standard BIP-39 e uma mensagem curta em inglês. Em sucesso result e entropy_hex guardam o hex recuperado em minúsculas, mnemonic é a frase normalizada, checksum_valid é true e os mesmos campos de tamanho entram. Descompasso de checksum devolve invalid_input com mensagem que nomeia falha de checksum BIP-39 para clientes e testes dourados combinarem uma substring. text ausente, mode desconhecido, mnemônico vazio, contagem errada e palavras desconhecidas também devolvem invalid_input e nunca são cobrados.
Vetores práticos, dicas de teste e diferença da derivação de semente
Altere de propósito a última palavra de uma frase válida de doze palavras para abandon e afirme invalid_input com string de correspondência de descompasso de checksum. Mantenha fontes de entropia offline e de alta qualidade ao construir carteiras reais; esta API nunca amostra aleatoriedade e nunca armazena seus bytes.
Casos de integração
Fixtures de carteira e checagens de CI
Codifique entropia hex conhecida em frases BIP-39 para testes dourados; depois decodifique e afirme checksum_valid para bibliotecas de carteira não desviarem do BIP em silêncio.
Verificação segura de mnemônicos colados
Decodifique frases semente fornecidas pelo usuário e rejeite palavras erradas ou checksums quebrados com invalid_input antes de qualquer passo de derivação de semente.
Perguntas técnicas
Quanto custa o codificador de mnemônicos BIP-39?
A ferramenta no navegador é gratuita. Requisições à API usam saldo pré-pago KIT a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.