:::note **TL;DR** - A Latin name has no single Hebrew spelling, so one name honestly yields several gematria numbers. Shulamith scores 787, 401, 552 or 166 depending on which reading of the letter map you accept. - `POST /kabbalah/gematria` returns every candidate spelling with its own cipher values and its own per letter breakdown, names the one it scored, and states the rule that chose it. - Eleven rabbinic ciphers, two rabbinic substitution methods and three Latin alphabet ciphers, every row carrying its tradition and its century, so a Renaissance Christian cipher is never served as rabbinic practice. - Build a gematria calculator, a birth name page or a Tree of Life explorer on the [Kabbalah API](/products/kabbalah-api "production ready Kabbalah API with gematria, the 72 names and the Tree of Life"), one of 18+ insight domains on a single key. ::: Type the same name into two gematria calculators and you will often get two different numbers. Neither site tells you why, so the natural assumption is that one of them is broken. Both can be correct. Gematria scores Hebrew letters, which means a Latin name has to be written in Hebrew before it can be scored at all, and that writing step has more than one legal answer. A gematria calculator API is only honest if it publishes the choice it made. That is the design behind the Kabbalah API that went live on roxyapi.com today: 12+ Kabbalah endpoints, part of 258+ endpoints across 18+ insight domains like Western astrology, Vedic astrology and tarot on one key, covering gematria, the 22 Hebrew letters, the Tree of Life, the 72 names and the Hebrew birthday, with every school split exposed as a typed request field instead of a hidden default. ## Why do two gematria calculators disagree about the same name? Because they wrote the name in Hebrew differently and said nothing about it. Every Hebrew letter carries a numeric value, so gematria is plain arithmetic once a spelling exists. Producing that spelling is the hard part, and there is no published standard for turning a Latin name into Hebrew. The standards run the other way: ISO 259 is titled transliteration of Hebrew characters into Latin characters, as are its later parts. A calculator that prints one number has therefore picked one spelling in silence. The published letter map behind this API is deterministic and still ambiguous, because some of its entries are two letters long. The pair `th` reads as tav, one letter, or as tet followed by he, two letters. The pair `sh` reads as shin, or as samekh followed by he. A name with two such junctions has four legal readings. :::stat 4 spellings **One Latin name, four legal Hebrew spellings**, four different totals, returned in one call. Captured live from [`POST /kabbalah/gematria`](/api-reference#tag/kabbalah/POST/kabbalah/gematria "gematria endpoint returning every candidate Hebrew spelling with its cipher values"). ::: | Hebrew spelling | Romanization | Mispar hechrachi | Tradition and century | How the map read it | |---|---|---|---|---| | שולאמית | ShVLAMITh | 787 | rabbinic, second century onward | sh as shin, th as tav | | שולאמיטה | ShVLAMITH | 401 | rabbinic, second century onward | sh as shin, th as tet plus he | | סהולאמית | SHVLAMITh | 552 | rabbinic, second century onward | sh as samekh plus he, th as tav | | סהולאמיטה | SHVLAMITH | 166 | rabbinic, second century onward | sh as samekh plus he, th as tet plus he | All four rows come from one live call sending `{"text": "Shulamith"}`, one cipher on one input. The disagreement sits entirely upstream of the arithmetic, in a step most calculators never show. Ready to build this? [Kabbalah API](/products/kabbalah-api "production ready Kabbalah API with gematria, the 72 names and the Tree of Life") returns every candidate spelling with the rule that chose it, so your users see the working instead of a bare number. [See pricing](/pricing "RoxyAPI pricing and plan tiers"). ## What does a gematria calculator that shows its work return? Every parse, not one. The `hebrewForms` array carries each candidate spelling with its own cipher values, its own glyph by glyph breakdown, and a `rule` sentence saying why that parse exists. The `chosen` object names the spelling the headline `values` came from. The `conventions` object echoes every switch the result was computed with, so a reading stored today can be reproduced years from now without knowing what the defaults were on the day. ```json { "input": { "text": "Shulamith" }, "hebrewForms": [ { "hebrew": "שולאמית", "romanization": "ShVLAMITh", "rule": "Longest match first: every two letter group the table prints is read as one Hebrew letter before the single letters are tried.", "values": [{ "id": "mispar-hechrachi", "value": 787, "tradition": "rabbinic", "source": "..." }], "letters": [ { "glyph": "ש", "letterId": "shin", "name": "Shin", "isFinal": false, "value": 300 }, { "glyph": "ו", "letterId": "vav", "name": "Vau", "isFinal": false, "value": 6 }, { "glyph": "ל", "letterId": "lamed", "name": "Lamed", "isFinal": false, "value": 30 }, { "glyph": "א", "letterId": "alef", "name": "Aleph", "isFinal": false, "value": 1 }, { "glyph": "מ", "letterId": "mem", "name": "Mem", "isFinal": false, "value": 40 }, { "glyph": "י", "letterId": "yod", "name": "Yod", "isFinal": false, "value": 10 }, { "glyph": "ת", "letterId": "tav", "name": "Tau", "isFinal": false, "value": 400 } ] }, { "hebrew": "סהולאמיטה", "romanization": "SHVLAMITH", "rule": "An alternative parse: at least one two letter group is read as two separate Hebrew letters instead of one.", "values": [{ "id": "mispar-hechrachi", "value": 166, "tradition": "rabbinic", "source": "..." }] } ], "chosen": { "hebrew": "שולאמית", "rule": "Longest match first: every two letter group the table prints is read as one Hebrew letter before the single letters are tried." }, "values": [ { "id": "mispar-hechrachi", "value": 787, "tradition": "rabbinic", "source": "..." }, { "id": "mispar-katan", "value": 22, "tradition": "rabbinic", "source": "..." } ], "transformations": [ { "id": "atbash", "output": "בפכתימא", "outputRomanization": "BPKThIMA", "value": 553, "tradition": "rabbinic" }, { "id": "albam", "output": "יפאלבשך", "outputRomanization": "IPALBShK", "value": 443, "tradition": "rabbinic" } ], "matches": [], "conventions": { "transliteration": "letter-map-mathers", "misparGadol": "finals-500-900", "atbashOutput": "both" } } ``` Trimmed from a live response for width: two of the four forms are shown, the middle two dropped, `letters` is printed on the first form only, each `values` list is cut to the ciphers the request asked for, and each `source` URL is elided. Nothing is invented and no value is altered. Add the numbers on the first form and you get 300 plus 6 plus 30 plus 1 plus 40 plus 10 plus 400, which is the 787 at the top of the response. Two failure modes return a 400 that names the problem rather than a number that is quietly wrong. Five Latin letters, `c`, `e`, `f`, `w` and `x`, have no Hebrew in the published map, so `Elizabeth` is rejected with the letters it could not write listed by name. Sending `text` and `textHebrew` together is also rejected, because which one you send decides whether a transliteration step runs at all. ## Which gematria ciphers are rabbinic, and which are Renaissance Latin? `GET /kabbalah/ciphers` answers that on the row itself. It returns 16 rows in three groups, and each row states its identifier, its definition, its tradition, the century of that tradition, whether it is computed, and the sources it was built from. Eleven are rabbinic ciphers, two are rabbinic substitution methods, and three are Latin alphabet ciphers that consumer sites routinely print under a Hebrew heading. | Identifier | Name | Tradition | Century | Computed | |---|---|---|---|---| | `mispar-hechrachi` | Absolute value | rabbinic | Second century onward | yes | | `mispar-gadol` | Large value | rabbinic | Second century onward | yes | | `otiyot-be-milui` | Filled letters | rabbinic | Second century onward | yes | | `mispar-katan` | Small value | rabbinic | Second century onward | yes | | `mispar-kidmi` | Preceding value | rabbinic | Second century onward | yes | | `mispar-prati` | Squared value | rabbinic | Second century onward | yes | | `mispar-mispari` | Mispar mispari | rabbinic | Second century onward | no | | `atbash` | AtBash | rabbinic | Biblical | yes | | `albam` | Albam | rabbinic | Second century onward | yes | | `simple-ordinal` | Simple ordinal | renaissance-latin | Sixteenth century | yes | | `latin-mispar` | Latin mispar | renaissance-latin | Sixteenth century | yes | | `ordinal-times-six` | Ordinal times six | modern | Modern | yes | Twelve of the sixteen rows the catalogue returns, captured live. The century labels are not decoration: the 1906 Jewish Encyclopedia dates the term gematria to the twenty ninth of the thirty two hermeneutic rules of Rabbi Eliezer ben Rabbi Jose the Galilean, around the year 200, and records the two biblical substitution cases at Jeremiah 25:26 and 51:1 that AtBash is read from. Sending `latinCiphers: true` scores the Latin string too, and each of those three rows returns a `lineage` sentence rather than a bare label. The row identified as `latin-mispar` reports that it is structurally the Agrippa code of 1533 and that it is popularly published under a Jewish label while not being a Jewish cipher. That sentence ships inside the response, so a product cannot misattribute it by accident. One row returns `value: null` with `computed: false`, because mispar mispari needs a table of Hebrew number words no consulted source carries and its own published worked example yields two answers. Mispar gadol is the opposite case, one name over two published methods: the 1906 encyclopedia lists a major value counting the five word final letters as hundreds, and separately a nominal value scoring each letter as its own spelled out name. Both are real and they give different numbers, so `misparGadol` is a request field. ## How do you find the 72 names of God from a birth date? The 72 names come from three consecutive verses of Exodus, chapter 14 verses 19 to 21, each of exactly 72 letters, read boustrophedon, one letter taken from each verse in turn to produce 72 names of three letters. The Renaissance lineage published by Johann Reuchlin in 1517 makes them pronounceable by adding a suffix. Each name is mapped to a five degree arc of ecliptic longitude, which is how a birth date selects one. This API derives them from the verses rather than storing a table, because a stored table agrees with itself forever and proves nothing. The derivation reproduces the published Reuchlin list on all 72 rows, and the single row where a second published list prints different letters carries that disagreement instead of a silent correction: ```bash curl "https://roxyapi.com/api/v2/kabbalah/names/39" -H "X-API-Key: $ROXY_API_KEY" # => number 39, name "רהעאל", traditionalName "Rehael", # letters "רהע", lettersAsWritten "רהע", # publishedDisagreement { list: "a second published list of the seventy two names", prints: "רעה" }, # arcStart 190, arcEnd 195, sign "libra", choir "Powers" ``` `POST /kabbalah/birth-profile` returns three names for one birth, with the roles `body`, `character` and `spirit`, alongside the Hebrew date and the Hebrew birthday. The first is read from the arc the Sun stood in, the second from a faster cycle repeating five times a year, the third from the twenty minute interval of the clock. How the day is dated is itself a convention, and the two published methods drift apart across the year, so `angelDating` is a request field. | Request for 1990-08-05, 14:30, America/New_York | `body` name | `character` name | `spirit` name | |---|---|---|---| | `angelDating: "solar-longitude"`, Hermetic 1823 wheel | 27, Ierathel, Dominions | 64, Mehiel, Archangels | 44, Ielahiah, Virtues | | `angelDating: "lenain-blocks"`, Hermetic 1823 wheel | 28, Saeehiah, Dominions | 64, Mehiel, Archangels | 44, Ielahiah, Virtues | Both rows captured live. The exact arc of the Sun and the fixed civil wheel of five day blocks name a different first angel for the same birth, which is why a product printing one of them without saying which is printing an unreproducible answer. ## Why is every school choice a typed parameter instead of a silent default? Because Kabbalah is not one tradition, and a hidden default turns a school choice into a stated fact. Ten optional request fields carry the disagreements, each with a named default, each echoed back inside `conventions` on the response. Change one and the answer changes in a way the caller can trace and reproduce, rather than in a way that reads as a bug report. The clearest live case is the letter attributions. Bet is a planet under all four readings, and the four readings name three different planets for it: ```bash curl "https://roxyapi.com/api/v2/kabbalah/letters?letterAttribution=golden-dawn" \ -H "X-API-Key: $ROXY_API_KEY" # bet => attribution { kind: "planet", value: "moon" } under sefer-yetzirah-gra # bet => attribution { kind: "planet", value: "saturn" } under sefer-yetzirah-short # bet => attribution { kind: "planet", value: "saturn" } under sefer-yetzirah-saadia # bet => attribution { kind: "planet", value: "mercury" } under golden-dawn # he => attribution { kind: "sign", value: "aries" } under all four # tzadi => attribution { kind: "sign", value: "aquarius" } under all four ``` That last pair is worth checking against your own reference. A widely repeated claim holds that the Golden Dawn exchanges he and tzade; the books written from Golden Dawn material print he with Aries and tzade with Aquarius, so this API performs no such exchange and returns those two rows identically under all four readings. | Convention | Values | Default | Tradition and century | What it changes | |---|---|---|---|---| | `transliteration` | `letter-map-mathers` | `letter-map-mathers` | Hermetic, 1887 | How a Latin name is written in Hebrew before it is scored | | `misparGadol` | `finals-500-900`, `milui` | `finals-500-900` | rabbinic, second century onward | Which of the two published large value methods the name means | | `atbashOutput` | `both`, `string`, `value` | `both` | rabbinic, biblical | Whether a substitution returns the Hebrew string, its value, or both | | `letterAttribution` | four readings | `sefer-yetzirah-gra` | rabbinic tenth century onward, plus Hermetic nineteenth century | Which element, planet or sign each letter carries | | `treeVariant` | `kircher` | `kircher` | Hermetic, 1652 | Which arrangement of the 22 paths is drawn | | `angelDating` | `solar-longitude`, `lenain-blocks` | `solar-longitude` | Hermetic, 1823 wheel | How the name governing the day of birth is dated | | `afterSunset` | `true`, `false` | `false` | rabbinic, biblical | Whether the birth fell after nightfall, which starts the next Hebrew date | ## How to call the gematria endpoint from curl, TypeScript or Python One POST turns a name into its Hebrew spellings and their numbers. The `ciphers` array narrows the top level `values`, and every entry in `hebrewForms` keeps its full cipher set so the candidates stay comparable. :::tabs ### curl ```bash curl -X POST https://roxyapi.com/api/v2/kabbalah/gematria \ -H "X-API-Key: $ROXY_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "text": "Shulamith", "ciphers": ["mispar-hechrachi", "mispar-katan"] }' ``` ### TypeScript ```typescript import { createRoxy } from '@roxyapi/sdk'; const roxy = createRoxy(process.env.ROXY_API_KEY!); const { data: gematria } = await roxy.kabbalah.calculateGematria({ body: { text: 'Shulamith', ciphers: ['mispar-hechrachi', 'mispar-katan'] }, }); console.log(gematria.chosen.hebrew); // "שולאמית" console.log(gematria.values[0].value); // 787 console.log(gematria.hebrewForms.length); // 4 console.log(gematria.conventions.misparGadol); // "finals-500-900" ``` ### Python ```python import os from roxy_sdk import create_roxy roxy = create_roxy(os.environ['ROXY_API_KEY']) gematria = roxy.kabbalah.calculate_gematria( text='Shulamith', ciphers=['mispar-hechrachi', 'mispar-katan'], ) for form in gematria['hebrewForms']: print(form['hebrew'], form['romanization'], form['rule']) ``` ### Remote MCP ```bash claude mcp add-json --scope user roxy-kabbalah '{"type":"http","url":"https://roxyapi.com/mcp/kabbalah","headers":{"X-API-Key":"YOUR_KEY"}}' ``` ::: The birth profile takes no latitude and no longitude, because nothing in this domain needs a place: the Sun position is geocentric, the Hebrew calendar is arithmetic, and the sunset boundary is a flag the caller sets. It does take an IANA timezone, so resolve that from a city first rather than asking a user to type one. ```bash curl "https://roxyapi.com/api/v2/location/search?q=Brooklyn" -H "X-API-Key: $ROXY_API_KEY" # => cities[0] { city: "Brooklyn", province: "New York", timezone: "America/New_York", utcOffset: -4 } curl -X POST https://roxyapi.com/api/v2/kabbalah/birth-profile \ -H "X-API-Key: $ROXY_API_KEY" -H "Content-Type: application/json" \ -d '{"date":"1990-08-05","time":"14:30","timezone":"America/New_York"}' # => hebrewDate { year: 5750, month: "Av", day: 14, hebrew: "י״ד באב תש״נ", afterSunset: false }, # hebrewBirthday { date: "1991-07-25", hebrewYear: 5751 }, # angels 3 entries, sephirah { id: "chesed", number: 4, english: "Mercy" } ``` Add `?lang=de` to the same gematria call and the composed prose comes back in German while the identifiers hold: a live request returns the rule sentence as `Die gesendete Schreibweise. Es wurde keine Transliteration angewendet`, with `id` still `mispar-hechrachi` and `tradition` still `rabbinic`. Branch on the identifier, render the prose. The fourth tab is the Remote MCP server for this domain, Streamable HTTP with no local setup, which is what a deployed agent connects to when it needs real calculations. A coding assistant that is helping you integrate connects the keyless docs server at `/mcp/docs` instead, and both routes are covered in the [Remote MCP guide](/docs/mcp "Remote MCP setup for Claude Code, Cursor, ChatGPT and other clients"). The endpoint by endpoint walkthrough lives in the [Kabbalah guide](/docs/guides/kabbalah "Kabbalah API guide with response shapes, conventions and gotchas"). ## FAQ **What is a gematria calculator API?** A gematria calculator API turns a word or a name into its Hebrew numeric value over HTTP, so an app does not have to ship its own letter tables. The RoxyAPI version returns every candidate Hebrew spelling of a Latin name, each with its own cipher values and a per letter breakdown, plus the spelling it scored and the rule that selected it. Eleven rabbinic ciphers are catalogued, ten of them computed, and every row states its tradition and its century. **Why do two gematria calculators give different numbers for my name?** Almost always because they wrote your name in Hebrew differently and did not say so. There is no published standard for turning a Latin name into Hebrew, since the standards romanize in the other direction, so each site quietly picks one spelling. RoxyAPI takes the transliteration scheme as a typed parameter, returns every candidate spelling instead of one, and echoes the convention on the response, so two answers can be compared rather than argued about. **How do I get the gematria of a Hebrew word rather than a Latin name?** Send `textHebrew` instead of `text`. The transliteration step is skipped entirely, exactly one form comes back, and `transliteration` drops out of `conventions` because no scheme was applied. Vowel points and cantillation marks are removed before scoring, so a pointed and an unpointed spelling of one word return the same number. **Can I find my 72 names of God angel from my birth date?** Yes. `POST /kabbalah/birth-profile` returns three names for one birth, with the roles body, character and spirit, each carrying the arc or the clock interval it governs. How the day is dated is a convention with two published methods that drift apart across the year, so RoxyAPI exposes `angelDating` as a request field and names the method that produced the answer on every response. **Does the RoxyAPI Kabbalah API compute the Hebrew calendar?** It computes a Hebrew birthday, not a calendar. The Hebrew date of a birth, the anniversary that follows it and the sunset boundary are fields inside the birth profile, worked out from the published calendar algorithm. There are no holidays, no candle times and no Torah readings, because that ground is already well covered elsewhere and duplicating it would add no value. **Is there a free way to test the gematria endpoint before buying?** Yes. Every Kabbalah operation runs live in the browser from the [API reference](/api-reference#tag/kabbalah/POST/kabbalah/gematria "run the gematria endpoint live against production, no signup required"), returning real production responses with no signup and no API key. Once you subscribe, all 18+ domains are included in one flat plan at 1 request equals 1 unit, with no per domain surcharge. ## Conclusion A gematria number is only trustworthy when the Hebrew behind it is visible, and a Kabbalah dataset is only citable when every row names its tradition and its century. That is what shipped today: every candidate spelling with its own breakdown, eleven rabbinic ciphers plus three Latin ones labelled by lineage, the 72 names derived from the verses rather than copied from a table, and every school split as a typed field you can reproduce. Start with the [Kabbalah API](/products/kabbalah-api "production ready Kabbalah API with gematria, the 72 names, the Tree of Life and the Hebrew birthday") on the same key that already carries 18+ insight domains, from 39 dollars a month on the Starter plan, or about 1.80 dollars per domain on annual billing.