Gematria Methods: 26 Systems with Examples

Last updated:

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.

Mispar Hechrachi מספר הכרחי Sum

Also known as: absolute, standard, ragil

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."

Worked example: אחד (echad) = 13

LetterName / StepValue
א Alef 1
ח Het 8
ד Dalet 4
Total (אחד · echad "one") 13

Mispar Gadol מספר גדול Sum

Also known as: large, sofit

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

LetterName / StepValue
ש 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.

Mispar Siduri מספר סידורי Sum

Also known as: ordinal

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

LetterName / StepValue
א 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.

Mispar Katan מספר קטן Sum

Also known as: small, reduced

Per-letter significant digit (10→1, 20→2, …, 300→3).

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

LetterName / StepValue
א 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.

Mispar Katan Mispari מספר קטן מספרי Derived

Also known as: integral reduced, digital root

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

LetterName / StepValue
א 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.

Mispar Perati מספר פרטי Sum

Also known as: squared, bonaeh

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.

Worked example: אחד (echad) = 81

LetterName / StepValue
א Alef 1² = 1
ח Het 8² = 64
ד Dalet 4² = 16
Total (אחד · echad "one") 81

1 + 64 + 16 = 81.

Mispar Milui / Shemi מספר מילוי Sum

Also known as: full, name-filling

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

LetterName / StepValue
א 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.

Mispar Ne'elam מספר נעלם Sum

Also known as: hidden

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

LetterName / StepValue
א 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.

Mispar Musafi מספר מוספי Derived

Also known as: added

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.

Worked example: אחד (echad) = 16

LetterName / StepValue
א+ח+ד Hechrachi 13
+3 Letter count 3
Total (אחד · echad "one") 16

13 (standard) + 3 (letters) = 16.

Mispar im ha-Kolel מספר עם הכולל Derived

Also known as: with the kolel

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.

Worked example: אחד (echad) = 14

LetterName / StepValue
א+ח+ד Hechrachi 13
+1 Word count (kolel) 1
Total (אחד · echad "one") 14

13 (standard) + 1 (one word) = 14.

Mispar Kidmi מספר קדמי Sum

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.

Worked example: אחד (echad) = 47

LetterName / StepValue
א Alef: Σ(alef) = 1 1
ח Het: Σ(א…ח) = 1+2+3+4+5+6+7+8 = 36 36
ד Dalet: Σ(א…ד) = 1+2+3+4 = 10 10
Total (אחד · echad "one") 47

1 + 36 + 10 = 47.

Mispar Meshulash מספר משולש Sum

Also known as: cubed

Sum of the cube of each letter's standard value.

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.

Worked example: אחד (echad) = 577

LetterName / StepValue
א Alef 1³ = 1
ח Het 8³ = 512
ד Dalet 4³ = 64
Total (אחד · echad "one") 577

1 + 512 + 64 = 577.

Mispar Meruba Klali מספר מרובע כללי Derived

Also known as: squared total

Square of the hechrachi total.

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

LetterName / StepValue
א+ח+ד Hechrachi total 13
13² Squared 169
Total (אחד · echad "one") 169

First sum all letters (13), then square the total.

Atbash אתב״ש Substitution

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

LetterName / StepValue
ש→ב 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.

Albam אלב״ם Substitution

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

LetterName / StepValue
א→ל 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.

Achbi אכב״י Substitution

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

LetterName / StepValue
ש→מ 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.

Mispar Bone'eh מספר בונה Sum

Also known as: building, cumulative-positional

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

LetterName / StepValue
א 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.

Mispar Ha'achor מספר האחור Sum

Also known as: positional, reverse-positional

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

LetterName / StepValue
א 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.

Mispar Mispari מספר מספרי Sum

Also known as: number-name, numeric-name

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.

Worked example: אחד (echad) = 687

LetterName / StepValue
א Alef=1 → name "אחד" (echad) = 1+8+4 13
ח Het=8 → name "שמונה" (shmoneh) = 300+40+6+50+5 401
ד Dalet=4 → name "ארבע" (arba) = 1+200+2+70 273
Total (אחד · echad "one") 687

13 + 401 + 273 = 687. Number-name spellings follow TorahCalc's convention.

Atbach אטב״ח Substitution

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

LetterName / StepValue
א→ט 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.

Ayak Bachar אי״ק בכ״ר Substitution

Also known as: aiq bekar, theosophic substitution

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

LetterName / StepValue
א→י 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).

Ofanim אופנים Substitution

Also known as: wheels, last-letter name

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

LetterName / StepValue
א→ף 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.

Achas Beta אח״ס בט״ע Substitution

Also known as: achas bta, plus-7 shift

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

LetterName / StepValue
א→ח 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.

Avgad אבג״ד Substitution

Also known as: next-letter

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.

Worked example: אחד (echad) = 16

LetterName / StepValue
א→ב Alef → Bet = 2 2
ח→ט Het → Tet = 9 9
ד→ה Dalet → He = 5 5
Total (אחד · echad "one") 16

2 + 9 + 5 = 16. Tav (ת=400) wraps to alef (א=1).

Reverse Avgad אבג״ד הפוך Substitution

Also known as: previous-letter, avgad reverse

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

LetterName / StepValue
א→ת 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).

Experimental Alef-Efes אל״ף־אֶפֶס Derived

Also known as: alef-zeroth, alef as zero

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

LetterName / StepValue
א 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.