Codificador mnemónico BIP-39
Dieciséis bytes de entropía en cero se convierten en «abandon» once veces seguido de «about»: BIP-39 pasa de 128 a 256 bits a entre 12 y 24 palabras inglesas con un control SHA-256, y solo recupera la entropía si ese control coincide. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Texto
- 00000000000000000000000000000000
- Modo de cálculo
- Encode
- Entrada
- 00000000000000000000000000000000
- Entropía en hex
- 00000000000000000000000000000000
- Número de palabras
- 12
- Bits de entropía
- 128
BIP-39 es el estándar de la industria que transforma la entropía binaria de una cartera en un mnemónico legible de doce a veinticuatro palabras inglesas y recupera la misma entropía solo cuando los bits de suma de control SHA-256 embebidos siguen coincidiendo. La validación fallida no se factura; las llamadas correctas cuestan el precio base publicado por elemento.
Cómo BIP-39 asigna la entropía a palabras y al revés
BIP-39 parte de entropía en bruto de ciento veintiocho, ciento sesenta, ciento noventa y dos, doscientos veinticuatro o doscientos cincuenta y seis bits. La especificación toma los primeros ENT divididos entre treinta y dos bits del resumen SHA-256 de esos bytes de entropía y los añade como suma de control, produciendo una cadena de bits cuya longitud es siempre múltiplo de once. Cada grupo de once bits es un índice en una lista fija de dos mil cuarenta y ocho palabras inglesas ordenadas alfabéticamente de abandon a zoo.
Doce palabras corresponden a ciento veintiocho bits de entropía más cuatro bits de suma; quince, dieciocho, veintiuna y veinticuatro palabras escalan del mismo modo hasta doscientos cincuenta y seis bits más ocho bits de suma. La codificación queda por tanto determinada por los bytes de entropía y la lista: no hay sal, no hay elección de idioma en esta capacidad más allá del inglés, ni paso de derivación de clave privada.
La decodificación invierte el mapa: parte la frase por espacios, busca cada palabra, reconstruye la cadena de bits, separa la ventana final de suma y comprueba que esos bits coinciden con los bits iniciales de SHA-256 de la entropía recuperada. Si alguna palabra es desconocida, el recuento no es una de las cinco longitudes legales o los bits de suma no coinciden, la operación falla.
Ese diseño de fallo seguro es por lo que las carteras prefieren mnemónicos frente al hex en bruto para copias de seguridad humanas: una sola palabra incorrecta casi siempre hace fallar la suma en lugar de abrir otra cartera. Esta página atiende a quien busca un codificador de mnemónicos BIP-39, un convertidor de entropía a frase semilla o un verificador de suma de mnemónico; no ejecuta derivación de semilla PBKDF2, no genera entropía aleatoria y no admite listas de palabras no inglesas.
Vectores prácticos, consejos de prueba y diferencia con la derivación de semilla
Prefiera decode cuando una persona haya pegado una frase y deba recuperar la entropía solo si la suma de control está intacta. La entropía clásica de dieciséis bytes todo ceros se codifica como once palabras abandon seguidas de about; la de dieciséis bytes con todos los bits a uno se codifica como once zoo seguidas de wrong. Haga el viaje de ida y vuelta en CI: codifique, afirme el mnemónico, decodifique y afirme el hex original.
Use una herramienta BIP-32 o PBKDF2 aparte si necesita la semilla de sesenta y cuatro bytes a partir del mnemónico y una frase de paso opcional: ese paso queda deliberadamente fuera de alcance para que la landing SEO se centre en codificar y decodificar con verificación de suma. Al enseñar, muestre a los alumnos que dos mnemónicos que difieren en una palabra casi nunca comparten una suma válida, propiedad que hace más seguras las copias manuscritas que los volcados hex en bruto.
Combine esta capacidad con utilidades Base58Check o hex cuando su canal también formatee direcciones o claves privadas tras derivar la semilla en otro lugar.
Qué puede hacer con ella
Enseñanza de frases semilla con suma de control
Muestre los vectores clásicos todo ceros y todo unos; luego cambie una palabra para que se vea por qué BIP-39 falla de forma segura en lugar de abrir otra cartera.
Preguntas frecuentes
¿Cómo se convierte entropía hex en un mnemónico BIP-39?
Envíe mode encode (predeterminado) con text en 32, 40, 48, 56 o 64 dígitos hex (16–32 bytes).
¿Cómo se decodifica un mnemónico de vuelta a entropía?
Envíe mode decode con text en una frase BIP-39 inglesa de 12, 15, 18, 21 o 24 palabras.
¿Qué ocurre si la suma de control es incorrecta?
Las frases erróneas o mal escritas nunca se facturan ni devuelven entropía falsa.
¿Qué lista de palabras y longitudes se admiten?
Solo la lista oficial BIP-39 inglesa de 2048 palabras. La entropía debe ser de 128, 160, 192, 224 o 256 bits (recuentos de 12, 15, 18, 21 o 24 palabras).
¿Esta herramienta genera entropía aleatoria o la semilla de una cartera?
No. Solo convierte en palabras la entropía que usted aporta, y al revés, comprobando la suma de control. No genera entropía aleatoria, no deriva la semilla de la cartera a partir de la frase y una contraseña opcional, y solo trabaja con la lista de palabras en inglés.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su 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)Ejemplo de solicitud
{
"text": "00000000000000000000000000000000"
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.bip39",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
Este codificador de mnemónicos BIP-39 acepta la entropía en hexadecimal (dieciséis, veinte, veinticuatro, veintiocho o treinta y dos bytes) y devuelve la frase de la lista oficial inglesa; en modo decodificación asigna cada palabra a un índice de once bits, separa entropía y suma de control, recalcula SHA-256 de la entropía y devuelve invalid_input cuando los bits de suma no coinciden. La ruta gratuita del navegador y la API de prepago comparten el mismo módulo parse puro, de modo que vectores dorados como la entropía todo ceros, que produce once palabras abandon seguidas de about, coinciden byte a byte entre entornos.
Contrato de entrada, campos de respuesta y comportamiento de error
En modo encode, text debe ser entropía hexadecimal: tras quitar espacios, dos puntos, guiones bajos y guiones, la cadena debe tener longitud par y decodificar a exactamente dieciséis, veinte, veinticuatro, veintiocho o treinta y dos bytes. En modo decode, text es un mnemónico: las palabras se pasan a minúsculas y se parten por espacios, comas o puntos y comas; cada una debe figurar en la lista oficial inglesa; el recuento debe ser doce, quince, dieciocho, veintiuna o veinticuatro. Envíe un cuerpo JSON con un campo de cadena obligatorio text (alias: input, value, data, entropy y mnemonic) y un mode opcional encode o decode (por defecto encode). Longitud impar, caracteres no hex u otro recuento de bytes devuelven invalid_input indicando el problema. En éxito la respuesta repite el hex en minúsculas normalizado como input y entropy_hex, asigna result y mnemonic a la misma frase inglesa separada por espacios, e informa word_count, entropy_bits, checksum_bits, wordlist english, standard BIP-39 y un mensaje breve en inglés. En éxito result y entropy_hex contienen el hex recuperado en minúsculas, mnemonic es la frase normalizada, checksum_valid es true y se incluyen los mismos campos de tamaño. Un desajuste de suma devuelve invalid_input con un mensaje que nombra el fallo de suma BIP-39 para que clientes y pruebas doradas puedan coincidir en una subcadena. text ausente, mode desconocido, mnemónico vacío, recuento incorrecto y palabras desconocidas también devuelven invalid_input y nunca se cobran.
Vectores prácticos, consejos de prueba y diferencia con la derivación de semilla
Cambie a propósito la última palabra de una frase válida de doce palabras por abandon y afirme invalid_input con una cadena de coincidencia de desajuste de suma. Mantenga las fuentes de entropía fuera de línea y de alta calidad al construir carteras reales; esta API nunca muestrea aleatoriedad ni almacena sus bytes. Las tareas fallidas no consumen saldo prepago, lo que mantiene baratos los scripts exploratorios al probar frases incorrectas.
Casos de integración
Fixtures de cartera y comprobaciones CI
Codifique entropía hex conocida en frases BIP-39 para pruebas doradas; luego decodifique y afirme checksum_valid para que las bibliotecas de carteras no se desvíen del BIP en silencio.
Verificación de mnemónicos al pegar
Decodifique frases semilla aportadas por el usuario y rechace palabras mal escritas o sumas rotas con invalid_input antes de cualquier paso de derivación de semilla.
Preguntas técnicas
¿Cuánto cuesta el codificador de mnemónicos BIP-39?
La herramienta del navegador es gratuita. Las peticiones API usan saldo prepago KIT a $0.002 por llamada correcta; la entrada inválida no se factura.