Gematria assigns numeric values to Hebrew letters and words; the TorahML gematria calculator offers 26 methods, explained here with worked examples.
TorahML pairs gematria with base-rate checks in its experimental Cartography tool: how many coincidences would chance produce? A calculation alone is not a statistical test. Numerical matches are research leads; they do not establish meaning or historical relationships. Experimental rules are labeled.
What is Gematria?
Gematria assigns numeric values to Hebrew letters and words, then compares their totals. Hebrew letters also serve as numerals (alef=1, bet=2, …, tav=400). Shared values can prompt interpretation, but they do not by themselves establish a relationship in meaning or structure.
The practice appears in classical rabbinic literature, Kabbalistic texts, and biblical commentary. TorahML computes gematria algorithmically over the full Hebrew Tanakh, enabling systematic search across all 26 methods below.
Methods fall into three families: sum methods (sum a value per letter), derived methods (transform the sum itself), and substitution methods (replace letters via a cipher before summing).
Frequently Asked Questions
What is gematria?
Gematria is the practice of assigning numeric values to Hebrew letters and words, then finding numeric correspondences between them. Rooted in the alphanumeric structure of Hebrew (where letters double as numerals), it appears in rabbinic literature, Kabbalah, and biblical commentary. Modern implementations like TorahML compute gematria algorithmically over the full corpus.
What is Mispar Hechrachi (standard gematria)?
Mispar Hechrachi (also called Mispar Ragil or "absolute value") is the foundational method: alef=1, bet=2, gimel=3, …, yod=10, kaf=20, …, tav=400. Final (sofit) forms carry the same value as their base letter. This is the most widely used gematria system in classical Jewish sources.
How is Mispar Katan calculated?
Mispar Katan ("reduced value") strips trailing zeros from each letter's standard value before summing: mem (40) becomes 4, shin (300) becomes 3, qof (100) becomes 1. Mispar Katan Mispari goes further, reducing the entire word's Hechrachi total to a single digit via the digital root.
What is Atbash and where does it appear in the Bible?
Atbash is a substitution cipher that mirrors the Hebrew alphabet: alef↔tav, bet↔shin, gimel↔resh, and so on. It appears explicitly in Jeremiah 25:26, where "Sheshach" (ששך) is an Atbash encoding of "Babylon" (בבל). TorahML computes Atbash gematria by substituting each letter via the mirror mapping and then summing the standard values of the resulting letters.
What is the difference between Mispar Perati and Mispar Meruba Klali?
Both involve squaring, but at different stages. Mispar Perati squares each letter's value individually and then sums (e.g., for אחד: 1²+8²+4² = 1+64+16 = 81). Mispar Meruba Klali first sums all letters via Hechrachi, then squares the total (13² = 169). Perati is sensitive to which specific letters appear; Meruba Klali treats the word as a single numeric unit.
Is Alef-Efes a traditional gematria method?
No. Alef-Efes (א∅) is an interpretive, experimental rule — not a received traditional method. It belongs to the family of "Im HaKolel" adjustments. The rule proposes that alef may be read as 0 rather than 1, giving a word with k alefs a set of k+1 possible values. It is offered as a conceptual lens, not a measurement or historical practice. TorahML flags it explicitly as experimental.
What is Mispar Milui (full-name gematria)?
Mispar Milui ("name-filling") spells out the full Hebrew name of each letter and sums those letters' standard values. For example, Alef (א) is spelled א-ל-פ (alef-lamed-pe = 1+30+80 = 111). The related Mispar Ne'elam ("hidden value") subtracts the letter itself from its full-name value, keeping only the "hidden" remainder.
Standard absolute value; every letter (incl. finals) by its base value.
The foundational method used in classical rabbinic literature: each letter carries its conventional numeric value (א=1, ב=2, … ת=400), ignoring vowel marks. Also called Mispar Ragil or simply "standard gematria."
Like hechrachi but final forms (ךםןףץ) carry 500–900.
Extends standard gematria by assigning large values (500–900) to the five letters that have a final form (כמנפצ when written at end of a word). This doubles the numeric range and allows more discriminating comparisons.
Worked example: שָׁלוֹם (shalom) = 936
Letter
Name / Step
Value
ש
Shin
300
ל
Lamed
30
ו
Vav
6
ם
Mem-sofit
600
Total (שָׁלוֹם · shalom "peace")
936
In Mispar Hechrachi the final mem would carry 40 (total 376); here the sofit form carries 600.
Ordinal position 1–22; finals share their base letter's position.
Each letter is counted by its position in the Hebrew alphabet (alef=1 through tav=22) rather than its conventional weight. Final forms share the ordinal of their base letter. This method compresses the value range and links letters by sequential proximity.
Worked example: אחד (echad) = 13
Letter
Name / Step
Value
א
Alef
1
ח
Het
8
ד
Dalet
4
Total (אחד · echad "one")
13
Here each letter's value equals its position in the alef-bet (א=1st, ב=2nd, …), not the traditional numeric weight.
Strips trailing zeros from each letter's standard value before summing: mem (40) counts as 4, shin (300) as 3, qof (100) as 1. This changes which words share a numeric value. A match between unrelated roots does not establish a linguistic or historical relationship.
Worked example: אחד (echad) = 13
Letter
Name / Step
Value
א
Alef
1
ח
Het
8
ד
Dalet
4
Total (אחד · echad "one")
13
For this word, all standard values are single-digit so the result is the same as Hechrachi. Try שִׁיר (300→3, 10→1, 200→2) = 6.
Digital root of the hechrachi total (reduced to 1–9).
First computes the standard Hechrachi value, then repeatedly sums its digits until a single digit (1–9) remains — the "digital root." Two words with identical digital roots share this reduced equivalence, regardless of their full values.
Worked example: אחד (echad) = 4
Letter
Name / Step
Value
א
Alef
1
ח
Het
8
ד
Dalet
4
Total (אחד · echad "one")
4
Step 1: Hechrachi = 1+8+4 = 13. Step 2: digital root of 13 = 1+3 = 4.
Sum of the square of each letter's standard value.
Each letter's standard value is squared before summing. Also called Mispar Meruba Pratit ("individual squared"). Squaring amplifies differences between letters — a large letter such as shin (300² = 90,000) dominates heavily, making this method sensitive to which heavy letters appear.
Sum of the standard value of each letter's full-name spelling (canonical spellings).
Instead of counting the letter itself, you spell out its full name (e.g., Alef → א-ל-פ) and sum those letters' standard values. Also called Mispar Shemi ("name gematria"). This method is frequently used in Kabbalistic literature for analyzing Divine Names.
Worked example: אמן (amen) = 297
Letter
Name / Step
Value
א
Alef → אלף
1+30+80 = 111
מ
Mem → מם
40+40 = 80
נ
Nun → נון
50+6+50 = 106
Total (אמן · amen "amen / faithful")
297
Each letter is expanded to its full Hebrew name before summing.
Milui minus the letter itself: value of the name's 'hidden' part.
The "hidden" or "concealed" value: take each letter's full-name spelling (as in Milui), then subtract the letter itself, keeping only the letters that come after it in the name. This isolates what is "hidden inside" each letter's name.
Worked example: אמן (amen) = 206
Letter
Name / Step
Value
א
Alef: name=111, minus alef(1)
110
מ
Mem: name=80, minus mem(40)
40
נ
Nun: name=106, minus nun(50)
56
Total (אמן · amen "amen / faithful")
206
Milui of אמן = 297; Ne'elam = 297 − 91 (hechrachi of אמן) = 206.
Hechrachi total plus the number of letters in the text.
Adds the count of letters in the word to the standard Hechrachi value. This is a form of the "Im HaOtiyot" (with the letters) convention, which compensates for the fact that a single letter has a positive presence beyond its numeric weight.
Hechrachi total plus the number of words in the text (the kolel, +1 per word).
A classic rabbinic adjustment: adds the number of words to the Hechrachi total. The "kolel" (כולל, "totality") convention allows a numeric match to stand even when it is off by one, because each word as a whole also contributes a single unit.
Also known as: triangular, meshulash kidmi, cumulative
Each letter valued as the sum of all standard values from alef up to it.
Also called Mispar Meshulash Kidmi ("triangular-cumulative"). Each letter's value is the running sum of standard values from alef up to and including that letter. This produces a triangular-number sequence; the effect is that later letters in the alphabet carry much higher weights.
Each letter's standard value is cubed before summing. The exponential amplification makes this method highly discriminating: shin (300³ = 27,000,000) dominates any word it appears in. Useful for finding structural equivalences between short words and phrases.
Squares the overall Hechrachi total rather than individual letter values. Unlike Mispar Perati (which squares per-letter), this method is order-independent and treats the word as a single unit, then raises that unit to the second power.
Worked example: אחד (echad) = 169
Letter
Name / Step
Value
א+ח+ד
Hechrachi total
13
13²
Squared
169
Total (אחד · echad "one")
169
First sum all letters (13), then square the total.
Reflect the alphabet (א↔ת, ב↔ש, …), then sum standard values.
The oldest and most famous Hebrew substitution cipher: letter 1 (alef) swaps with letter 22 (tav), letter 2 (bet) swaps with letter 21 (shin), and so on. Atbash appears explicitly in the book of Jeremiah (Jer 25:26 "Sheshach" = Babylon). After substitution the standard values of the new letters are summed.
Worked example: שָׁלוֹם (shalom) = 112
Letter
Name / Step
Value
ש→ב
Shin(21)↔Bet(2) → 2
2
ל→כ
Lamed(12)↔Kaf(11) → 20
20
ו→פ
Vav(6)↔Pe(17) → 80
80
מ→י
Mem(13)↔Yod(10) → 10
10
Total (שָׁלוֹם · shalom "peace")
112
Each letter is replaced by its mirror across the alphabet before summing.
Swap the two halves of 11 letters (א↔ל, ב↔מ, …), then sum standard values.
Divides the 22-letter alphabet into two halves of 11, then swaps letters between the halves: alef↔lamed, bet↔mem, gimel↔nun, and so on. The name "Albam" encodes the first two pairs (א-ל, ב-מ). Used in biblical exegesis and Kabbalistic commentary.
Worked example: אחד (echad) = 190
Letter
Name / Step
Value
א→ל
Alef(1)→Lamed(12) → 30
30
ח→ק
Het(8)→Qof(19) → 100
100
ד→ס
Dalet(4)→Samekh(15) → 60
60
Total (אחד · echad "one")
190
Each letter shifts by 11 positions (wrapping around) before the standard value is taken.
Swap adjacent pairs (א↔ב, ג↔ד, …), then sum standard values.
Swaps adjacent letter pairs across two groups of 11: alef↔kaf, bet↔yod, gimel↔tet, and so on within each half. The name "Achbi" encodes the first swap (א↔כ, ב↔י). Like Atbash and Albam, it is applied by substituting letters then summing their standard values.
Worked example: שָׁלוֹם (shalom) = 746
Letter
Name / Step
Value
ש→מ
Shin(21)→Mem(13) → 40
40
ל→ת
Lamed(12)→Tav(22) → 400
400
ו→ו
Vav(6)→Vav(6) [self] → 6
6
מ→ש
Mem(13)→Shin(21) → 300
300
Total (שָׁלוֹם · shalom "peace")
746
Adjacent pairs swap: letters at odd positions (1,3,5,…) exchange with the next even position. The middle letter of each half-group maps back to itself.
Running cumulative within the word: each letter's standard value is multiplied by the number of letters from it to the end (inclusive). Σ vᵢ·(n−i) over 0-based position i, n = total letters.
Mispar Bone'eh ("building value") weights each letter by how many letters remain from it to the end of the word (inclusive). The first letter carries the heaviest multiplier, the last carries ×1. An equivalent formulation: sum the word's running left-to-right partial-sums.
Worked example: אחד (echad) = 23
Letter
Name / Step
Value
א
Alef: 1 × 3 (3 letters from alef to end)
3
ח
Het: 8 × 2 (2 letters from het to end)
16
ד
Dalet: 4 × 1 (1 letter remaining)
4
Total (אחד · echad "one")
23
3 + 16 + 4 = 23. Equivalently: the sum of the running partial-sums (1, 1+8, 1+8+4) = 1 + 9 + 13 = 23.
Each letter's standard value multiplied by its 1-based position in the word. Σ vᵢ·(i+1) (0-based i).
Mispar Ha'achor ("backward/positional value") multiplies each letter's standard value by its 1-based position from the left. This is the positional complement to Bone'eh: where Bone'eh weights letters by distance to the end, Ha'achor weights them by distance from the start.
Worked example: אחד (echad) = 29
Letter
Name / Step
Value
א
Alef: 1 × 1 (position 1)
1
ח
Het: 8 × 2 (position 2)
16
ד
Dalet: 4 × 3 (position 3)
12
Total (אחד · echad "one")
29
1 + 16 + 12 = 29. Unlike Bone'eh, the last letter carries the largest multiplier.
Each letter is replaced by the gematria (Hechrachi) of the spelled-out Hebrew name of its numeric value (e.g. alef=1 → the word אחד = 13), then those values are summed. Number-name spellings follow TorahCalc's convention.
Mispar Mispari ("numeric gematria") replaces each letter with the Hechrachi value of the Hebrew name of that letter's numeric value — a second-order substitution. Alef=1, whose Hebrew name is אחד (= 13); Het=8, whose name is שמונה (= 401); and so on. The spellings used follow the TorahCalc convention.
Decade-complement substitution: each letter is replaced by the letter whose value completes its "decade" — units complete to 10 (א↔ט), tens to 100 (י↔צ), hundreds to 1000 (ק↔ץ, with final forms carrying 500–900). Sum the substituted values.
Atbach (אטב"ח) is a decade-complement cipher: units (1–9) pair with the letter that brings them to 10 (א↔ט, ב↔ח, ג↔ז, ד↔ו — ה is self-complementing at 5+5); tens (10–90) pair to 100 (י↔צ, כ↔פ, ל↔ע, מ↔ס, נ↔נ); hundreds (100–400/900) pair to 1000. The name encodes the first two pairs (א-ט, ב-ח). After substitution the standard values of the resulting letters are summed.
Worked example: אחד (echad) = 17
Letter
Name / Step
Value
א→ט
Alef(1) + Tet(9) = 10 → Tet = 9
9
ח→ב
Het(8) + Bet(2) = 10 → Bet = 2
2
ד→ו
Dalet(4) + Vav(6) = 10 → Vav = 6
6
Total (אחד · echad "one")
17
9 + 2 + 6 = 17. Each letter swaps with the letter whose standard value completes the "decade" pair to 10/100/1000.
The 27 letters (including finals) are arranged in a 3×9 grid; each letter cycles within its column (units→tens→hundreds→units, i.e. ×10 modulo the row). Sum the substituted values.
Ayak Bachar (אי"קבכ"ר) — also spelled Aiq Bekar — arranges the 27 letters (22 base + 5 finals) into a 3×9 grid by value magnitude: row 1 = units (א–ט), row 2 = tens (י–צ), row 3 = hundreds (ק–ץ). Each letter substitutes the letter directly below it in the same column (wrapping from row 3 back to row 1). The name encodes the first column: alef(1)→yod(10)→qof(100) = אי"ק.
Worked example: אחד (echad) = 130
Letter
Name / Step
Value
א→י
Alef(1) → Yod(10): units × 10
10
ח→פ
Het(8) → Pe(80): tens × 10
80
ד→מ
Dalet(4) → Mem(40): units × 10
40
Total (אחד · echad "one")
130
10 + 80 + 40 = 130. Each letter moves one row down in the 9-column grid (wrapping units→tens→hundreds→units).
Each letter is replaced by the LAST letter of its own spelled-out Hebrew name (e.g. alef = אלף → ף), then those values are summed.
Ofanim ("wheels") is an unusual substitution: each letter is replaced not by a fixed partner but by the last letter of its own spelled-out name. Alef (א-ל-פ) ends in pe (ף=80); Bet (ב-י-ת) ends in tav (ת=400); and so on. The method's name alludes to the wheels (אופנים) of Ezekiel's vision — the letters cycle through their own spellings.
Worked example: אחד (echad) = 880
Letter
Name / Step
Value
א→ף
Alef (אלף) → last letter pe-sofit (ף) = 80
80
ח→ת
Het (חית) → last letter tav (ת) = 400
400
ד→ת
Dalet (דלת) → last letter tav (ת) = 400
400
Total (אחד · echad "one")
880
80 + 400 + 400 = 880. The "wheel" of each letter name rotates to reveal its final letter.
Substitution by a +7 shift through the first 21 letters of the alphabet (wrapping within those 21); tav (ת, the 22nd letter) is left unchanged. Sum the substituted values.
Achas Beta (אח"סבט"ע) shifts each letter +7 positions in the alphabet (positions 1–21 wrapping cyclically); tav, the 22nd letter, is unchanged. The name encodes the first pairs of the cipher: alef(1)→het(8) = א-ח, bet(2)→tet(9) = ב-ט, gimel(3)→samekh(15) = ג-ס. After substitution the standard values of the resulting letters are summed.
Worked example: אחד (echad) = 88
Letter
Name / Step
Value
א→ח
Alef(1) + 7 positions → Het(8) = 8
8
ח→ס
Het(8) + 7 positions → Samekh(15) = 60
60
ד→כ
Dalet(4) + 7 positions → Kaf(11) = 20
20
Total (אחד · echad "one")
88
8 + 60 + 20 = 88. The shift wraps within positions 1–21; tav (position 22) maps to itself.
Each letter is replaced by the NEXT letter in the alphabet (tav wraps to alef). Sum the standard values of the substituted letters.
Avgad advances each letter one step forward in the Hebrew alphabet: alef→bet, bet→gimel, …, shin→tav, tav→alef (wrap). The name itself illustrates the cipher: א-ב-ג-ד (alef→bet, bet→gimel, etc.). The substituted letters' standard values are then summed.
Each letter is replaced by the PREVIOUS letter in the alphabet (alef wraps to tav). Sum the standard values of the substituted letters.
Reverse Avgad is the mirror of Avgad: each letter steps one position backward in the Hebrew alphabet (alef wraps to tav). It is also called Avgad Hafuch (הפוך = reversed). The substituted letters' standard values are summed.
Worked example: אחד (echad) = 410
Letter
Name / Step
Value
א→ת
Alef → Tav = 400
400
ח→ז
Het → Zayin = 7
7
ד→ג
Dalet → Gimel = 3
3
Total (אחד · echad "one")
410
400 + 7 + 3 = 410. Alef (א=1) wraps back to tav (ת=400).
Interpretive valuation rule (family of Im HaKolel): each alef (א) may be read as 0. value() returns the FLOOR (Standard − alef_count); a word with k alefs has k+1 possible readings. Not a received method.
Alef-Efes (א∅) — alef as zero. A named valuation rule, like Im HaKolel: each א may be read as 0. One alef → two readings; more alefs → more. Supplies the zero the Hebrew counting-letters never had.
Worked example: אֶחָד (echad) = 12
Letter
Name / Step
Value
א
Alef → 0 (floor reading)
0
ח
Het
8
ד
Dalet
4
Total (אֶחָד · echad "one")
12
One alef → two possible readings: {12, 13}. The app displays the full set.