Albam Hebrew cipher
Swap each Hebrew letter with its partner in the other half of the alphabet: alef becomes lamed, bet becomes mem, and בראשית turns into מטלישכ. Run it again to get the original back. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- בראשית
- Result
- מטלישכ
- Length
- 6
- Letters transformed
- 6
Albam is the classical Hebrew substitution cipher that divides the twenty-two letter Hebrew alphabet into two equal halves and swaps every letter with its partner in the other half: alef maps to lamed, bet to mem, gimel to nun, and so on through kaf pairing with tav. Because the mapping is its own inverse, applying the same transform twice restores the original Hebrew letters, so one deterministic operation both encodes and decodes. People use Albam for biblical-cipher study, classroom monoalphabetic demos, puzzle books, and light Hebrew text obfuscation without installing crypto libraries.
How Albam swaps the two halves
Albam splits the traditional twenty-two letter Hebrew alphabet into a first half of eleven letters and a second half of eleven letters, then exchanges each letter with the one that sits in the same index of the opposite half. The first half is alef, bet, gimel, dalet, he, vav, zayin, het, tet, yod, kaf; the second half is lamed, mem, nun, samekh, ayin, pe, tsadi, qof, resh, shin, tav.
That yields the reciprocal pairs alef with lamed, bet with mem, gimel with nun, dalet with samekh, he with ayin, vav with pe, zayin with tsadi, het with qof, tet with resh, yod with shin, and kaf with tav. Final sofit forms at the ends of words—final kaf, mem, nun, pe, and tsadi—are reduced to their non-final base letters before the swap, and the mapped result is always written with the non-final partner so the table stays eleven-plus-eleven and round-trips stay stable on medial forms.
Characters outside that set—digits, punctuation, whitespace, Latin letters, emoji, and other scripts—pass through unchanged so bilingual notes keep their shape.
Encode, decode, validation rules, and common pitfalls
There is no separate encode or decode mode: the same request shape performs both directions. Paste plain Hebrew study phrases to hide them, or paste already-swapped text to reveal them. Mixed Hebrew and Latin phrases preserve Latin letters because only the Hebrew alphabet participates in Albam.
Do not confuse Albam with Atbash: Atbash mirrors the alphabet end-to-end so alef pairs with tav, while Albam pairs halves so alef pairs with lamed—different historical tables and different search intent. Softit input is accepted and mapped through base letters; after one pass the partner appears in non-final form, so a second pass recovers the medial base rather than re-emitting a sofit glyph, which is intentional for a stable teaching table.
Do not treat the result as encryption: anyone who knows the scheme can reverse it instantly, and the product page should never market Albam as a security control for secrets, passwords, or personal data. Prefer this landing when the search intent is literally albam hebrew cipher or albam encoder; Atbash, Caesar, and general monoalphabetic keyword tools answer different intents and should stay separate.
What you can do with it
Biblical-cipher and classroom demos
Show students the Albam half-alphabet table, encode a short Hebrew phrase, then decode with the same call to prove the mapping is an involution.
Puzzle and riddle obfuscation
Hide Hebrew scavenger-hunt clues and Easter eggs in Albam so readers can opt in, then reverse the same string with one more request.
FAQ
How do I encode text with the Albam Hebrew cipher?
The response result field holds the swapped string; method is always albam.
How do I decode Albam?
Use the same request. Albam is its own inverse: paste the transformed text into text and the result restores the original medial Hebrew letters.
Is the Albam cipher tool free?
The browser tool runs free on your device.
How is Albam different from Atbash?
Atbash mirrors the alphabet end-to-end (alef pairs with tav). Albam swaps the two halves of the alphabet (alef pairs with lamed). Different tables, different search intent.
What happens to final letter forms such as final mem?
Final forms of kaf, mem, nun, pe and tsadi are read as their base letters before the swap, and the partner is always written in its non-final form. A second pass therefore returns the base letter, not the final glyph, which keeps the table stable.
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/albam \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"בראשית"}'const res = await fetch("https://api.kit.forhosting.com/enc/albam", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "בראשית"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/albam",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "בראשית"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/albam", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"בראשית"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"בראשית"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/albam", 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": "בראשית"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.albam",
"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 capability takes a non-empty text field, returns the transformed string with a count of swapped Hebrew letters, leaves non-Hebrew characters unchanged, and rejects empty input with a clear invalid_input error.
How Albam works and what the response contains
Send a JSON body with the required string field text set to any non-empty message; aliases input, value, and s are accepted when clients reuse older form names. Empty strings fail immediately with invalid_input because there is nothing meaningful to transform and the product promise is a real substitution result. On success the response includes result with the transformed text, method equal to albam so downstream code can branch without sniffing shapes, length equal to the input character count, and letters_transformed counting how many Hebrew letter units actually swapped. Identical inputs always produce identical JSON because the path is pure character arithmetic with no network, no random seed, and no wall clock.
Encode, decode, validation rules, and common pitfalls
Missing text, non-string text, or an empty string all raise invalid_input and are not charged on the prepaid API. Whitespace-only strings that still have length greater than zero are accepted; only Hebrew letters swap, so a string of spaces returns itself with letters_transformed equal to zero.
API usage, pricing, classroom workflows, and practical limits
Call the free in-browser Albam Hebrew cipher for biblical-cipher demos, lecture slides, puzzle drafting, and one-off checks without writing a one-liner in every language. Support playbooks can reverse lightly obfuscated Hebrew ticket notes that staff intentionally wrote in Albam. Pair with numeral or gematria tools only when a later study step needs letter values—keep Albam on its own landing so SEO intent stays sharp for people searching the half-alphabet Hebrew cipher by name. Use the prepaid KIT API when a backend, serverless function, tutoring platform, or SDK needs a stable contract under balance at $0.002 per successful item; validation failures never consume balance after the engine rejects the request. A typical classroom workflow shows students the eleven-plus-eleven table on the board, encodes a verse fragment, then decodes it with the same endpoint to prove the mapping is an involution, and later contrasts Albam with Atbash and with true keyed monoalphabetic ciphers. Puzzle sites can precompute Hebrew clues for display and reveal them on demand with the same endpoint. Authors shipping SDKs can map the result field straight into a copy button while method and letters_transformed make OpenAPI examples self-explanatory. Keep payloads to ordinary text sizes appropriate for a Worker isolate item call; this tool is for messages and snippets, not multi-megabyte binary blobs.
Integration use cases
Pipeline and CI fixtures
Scripts and continuous-integration tests pin deterministic Albam outputs so accidental alphabet-table or sofit-handling changes fail fast.
Technical questions
What happens if text is empty?
The request fails with invalid_input. A non-empty string is required; empty input is not charged on the prepaid API.