ForHosting KIT · Developer Utilities

RFC 1751 S/KEY word encoder

The 64-bit key EB33 F77E E73D 4053 becomes TIDE ITCH SLOW REIN RULE MOT: six short English words that are easier to read aloud or copy by hand than hex, with parity bits that catch a mistyped word on the way back. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
Text
EB33 F77E E73D 4053
Calculation mode
Encode
You get
Result
TIDE ITCH SLOW REIN RULE MOT
Hex
EB33F77EE73D4053
Words
TIDE ITCH SLOW REIN RULE MOT
Key bytes
8

RFC 1751 defines a fixed convention for turning binary cryptographic keys into short strings of English words so people can read, remember, and type 64-bit and 128-bit material without hex fatigue. The same dictionary powers classic S/KEY one-time passwords: each eight-byte block becomes six words drawn from a 2048-word list of one-to-four-letter tokens, with two spare bits reserved for parity so transcription mistakes are caught on the way back. This capability encodes a hexadecimal key into that word form and decodes words back to uppercase hex, verifying the parity bits on every six-word group.

How RFC 1751 packs 64 bits into six English words

The RFC 1751 dictionary contains exactly two thousand forty-eight English words of one to four letters, so each word indexes eleven bits. Six words supply sixty-six bits: sixty-four bits of key material plus a two-bit parity field. Encoding walks each eight-byte half of your key as a bit stream, sums consecutive two-bit slices over the sixty-four data bits to form a parity nibble, appends the low two parity bits, then slices the sixty-six-bit result into six eleven-bit indices.

Those indices select words from the fixed list in uppercase, joined by spaces. A pure sixty-four-bit key therefore becomes exactly six words; a one-hundred-twenty-eight-bit key is two independent halves and becomes twelve words. Decoding reverses the map: each word must appear in the dictionary, six words rebuild nine bytes of bit packing, the first eight bytes form the candidate key half, and the stored two parity bits are compared against a fresh parity sum.

A mismatch means a mistyped word or a bit flip and is rejected with a clear parity-failure message rather than a silent wrong key. The dictionary never changes across implementations; that stability is why S/KEY OTPs, SNMP-era key printouts, and modern recovery tools can interoperate when they all claim RFC 1751. This page implements that classic word list only—not BIP-39 mnemonics, not EFF diceware, and not arbitrary passphrase generators—so search intent stays locked to human-readable key encoding with parity.

Where S/KEY-style word keys still earn their keep

Operators who still print or dictate sixty-four-bit material benefit from six short words far more than from sixteen hex digits, especially over a phone or a radio channel. S/KEY and OTP systems that already emit RFC 1751 phrases need a strict decoder that rejects parity failures instead of accepting a neighbor key that would authenticate the wrong principal. Security training labs teach transcription hygiene by showing how a single wrong word flips the parity bit and aborts decode.

Incident response notes sometimes store offline recovery material as human-readable word groups so a responder without a hex editor can still re-enter a key later. Documentation authors ranking for RFC 1751 or S/KEY words want a dedicated landing with a live tool rather than a generic Base32 or BIP-39 page, because the dictionary, parity rule, and key lengths differ. Failed validation does not consume balance.

Keep requests to the documented key sizes, pin the uppercase hex and word strings in tests, and you get reproducible transforms for recovery workflows, OTP tooling, and edge workers without standing up a full cryptography toolkit of your own.

S/KEY OTP phrase entry

Decode six-word S/KEY one-time password phrases back to the underlying 64-bit value with parity verification before accepting login material.

Human-readable key printouts

Encode 64-bit or 128-bit hex keys as six or twelve English words for verbal transfer, paper backups, or radio-friendly runbooks.

How do I convert a hex key to RFC 1751 words?

Send mode encode (or omit mode) with text set to 16 hex digits for a 64-bit key or 32 hex digits for a 128-bit key. Spaces and colons are ignored. The result field contains six or twelve uppercase dictionary words.

How do I decode English words back to hex?

Send mode decode with text set to six or twelve space-separated RFC 1751 words.

What happens if parity check fails?

A parity mismatch means at least one word was mistyped or corrupted; the capability never returns a guessed key.

Is this the same as BIP-39 mnemonic words?

No. RFC 1751 uses a different 2048-word list, packs 64-bit halves with a 2-bit parity field, and targets S/KEY-style keys—not HD wallet seed phrases.

What key formats can I paste?

Paste 16 hex digits for a 64-bit key or 32 for a 128-bit key. Spaces, colons, dashes and a leading 0x are ignored, so EB33 F77E E73D 4053 works as written. A 128-bit key comes out as twelve words.

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.

POSThttps://api.kit.forhosting.com/enc/rfc1751

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.

curl -X POST https://api.kit.forhosting.com/enc/rfc1751 \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"EB33 F77E E73D 4053"}'
{
  "text": "EB33 F77E E73D 4053"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "enc.rfc1751",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Invalid words, wrong word counts, illegal hex lengths, and parity failures raise invalid_input instead of inventing a key.

Input contract, modes, and error behaviour

When mode is omitted, encode is the default. Encode mode treats text as a hexadecimal key: optional 0x prefix, spaces, colons, and dashes are stripped; the cleaned digit count must be sixteen for a sixty-four-bit key or thirty-two for a one-hundred-twenty-eight-bit key; any other length fails immediately. Decode mode treats text as whitespace-separated English words, folds them to uppercase, applies the historic S/Key letter substitutions that map digit one to L, zero to O, and five to S, and requires a positive multiple of six words. POST a JSON body with a required string field named text and an optional mode set to encode or decode. Success payloads always include mode, the original text, a primary result field (words when encoding, uppercase hex when decoding), plus echoed hex and words fields, key_bytes, key_bits, word_count, a standard label of RFC 1751, and parity_ok true when the transform completed. Missing text, non-string objects, unsupported mode values, odd hex lengths, non-hex characters, unknown dictionary words, badly formed tokens longer than four letters, word counts that are not multiples of six, and failed parity checks all raise invalid_input with an English message naming the problem. Validation failures do not consume prepaid balance. The free browser form is ideal for a single key you are about to type; scripts should pin the same JSON fields for regression goldens. Successful API calls use the published base price of $0.002 per item.

Cross-language golden fixtures

Generate encode and decode vectors that match RFC 1751 reference implementations so multi-language CI shares one ground truth.

What does the RFC 1751 word converter cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →