Kabbalah API reference

Kabbalah API for gematria, the 72 names, the Tree of Life and the Hebrew birthday. Score a Hebrew word or a Latin name across 11 rabbinic ciphers with the per letter breakdown, every candidate Hebrew spelling shown and the rule that chose one, plus a cited equal value lexicon. The 72 names are derived from the verses rather than copied from a table, the birth name is dated by the exact position of the Sun or by the civil wheel as you choose, and the sephirot, the 22 paths and the 22 letters come back under typed school variants cross linked to the tarot deck. One key covers every RoxyAPI domain, with Remote MCP and typed SDKs.

12 endpoints. Product page. Typed SDKs in six languages carry every operation below.

Your API keyKept in this tab only. Without a key, a small daily allowance still answers every request below.

Calculate gematria - Hebrew gematria calculator API with every spelling shown

POST /api/v2/kabbalah/gematria

Score a Hebrew word or a Latin name across ten rabbinic gematria ciphers and two substitution transformations, with the per letter breakdown and the curated equal value matches beside each number. A Latin name has no single Hebrew spelling, so every candidate spelling the transliteration map produces comes back with its own values and the rule that produced it, and the chosen one is named. Built for name meaning features, numerology apps that want the Hebrew reading, and any product that has to show a reader why the number is what it is.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.

Request body

Field	Type	Description
`text`	string	Latin text to write in Hebrew and then score, up to 200 characters. Non Latin scripts are folded to Latin first, so a Cyrillic or Devanagari name works. Send textHebrew instead to control the Hebrew spelling yourself.
`textHebrew`	string	Hebrew text to score, up to 200 characters. Anything outside the Hebrew script is rejected. Vowel points, cantillation marks, maqaf and paseq are removed before scoring, so a pointed and an unpointed spelling of one word give the same number.
`transliteration`	string enum	How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
`ciphers`	array of string enum	Which ciphers to return, by identifier. Omit for every computed cipher. Valid values are mispar-hechrachi, mispar-gadol, otiyot-be-milui, mispar-katan, mispar-kidmi, mispar-prati, mispar-ha-merubah-ha-klali, mispar-meshulash, mispar-musafi, kolel.
`misparGadol`	string enum	Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
`atbashOutput`	string enum	What AtBash and Albam return: the substituted Hebrew string, its standard value, or both. The biblical witness for AtBash is a substituted WORD rather than a number, which is why the string is available on its own.
`includeMatches`	boolean	Whether to return the curated equal value entries for the chosen spelling. Set false to skip the lookup when only the numbers are wanted.
`latinCiphers`	boolean	Whether to also score the Latin text with the three Latin alphabet ciphers. They are Renaissance Christian and modern in lineage rather than rabbinic, and the response labels each one. Ignored when textHebrew was sent.

curl

curl -X POST "https://roxyapi.com/api/v2/kabbalah/gematria" \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Sarah","textHebrew":"שלום","transliteration":"letter-map-mathers","ciphers":["mispar-hechrachi","mispar-gadol"]}'

Response fields

Field	Type	Description
`input` required	object
`input.text`	string	Echo of the Latin text sent. Absent when Hebrew was sent instead.
`input.textHebrew`	string	Echo of the Hebrew text sent. Absent when Latin was sent instead.
`hebrewForms` required	array of object	Every Hebrew spelling the input can be written as, greedy parse first. One entry when Hebrew was sent, since there is nothing to choose.
`hebrewForms[].hebrew` required	string	One Hebrew spelling the Latin input can be written as. Data, identical in every language.
`hebrewForms[].romanization` required	string	Latin transcription of the Hebrew beside it, produced by one mechanical letter map. It is a label for reading the string back, never a pronunciation claim.
`hebrewForms[].rule` required	string	Why this spelling came out of the map: the parse rule first, then one sentence for every reading the scheme applied that the letters alone would not show, so a caller can tell the parses apart.
`hebrewForms[].values` required	array of object	Every computed cipher applied to this spelling, in catalogue order. The rows carry no display name, because they are the same ciphers in the same order for every spelling: read the names off the top level values array once.
`hebrewForms[].values[].id` required	string	Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
`hebrewForms[].values[].value` required	number	The number this cipher gives for the string. Always a number: the one catalogued cipher this API does not compute is absent from this array rather than present without a value, so no row here has to be guarded. Its catalogue entry carries computed false and says why.
`hebrewForms[].values[].alternateValues`	array of number	Other published totals for the same string, ascending. Present only where the cipher is not single valued: letter names have several accepted spellings, so several totals are equally published. Absent otherwise, so a caller can branch on presence.
`hebrewForms[].values[].tradition` required	string	Provenance class of the cipher, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English, so it stays safe to compare against in code.
`hebrewForms[].values[].source` required	string	The first published source this cipher was taken from.
`hebrewForms[].letters` required	array of object	The per letter breakdown of this spelling under the standard reading.

Show all fieldsShow fewer fields

Field	Type	Description
`hebrewForms[].letters[].glyph` required	string	The Hebrew letter as it stands in the string. Data, identical in every language.
`hebrewForms[].letters[].letterId` required	string	Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
`hebrewForms[].letters[].name` required	string	Display name of the letter, in the requested language. Branch on letterId, never on this.
`hebrewForms[].letters[].isFinal` required	boolean	True when the glyph is the word final form. Under the finals-500-900 reading the same letter scores differently in final position, which is why this is on the row.
`hebrewForms[].letters[].value` required	number	What this letter contributed under the standard reading, or under the finals reading when one applies.
`chosen` required	object
`chosen.hebrew` required	string	The spelling the values and matches on this response were taken from.
`chosen.rule` required	string	Why this spelling was chosen over the others.
`values` required	array of object	Every requested cipher applied to the chosen spelling, in catalogue order, each named as the catalogue names it. Only computed ciphers appear, so every row carries a number.
`values[].id` required	string	Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
`values[].value` required	number	The number this cipher gives for the string. Always a number: the one catalogued cipher this API does not compute is absent from this array rather than present without a value, so no row here has to be guarded. Its catalogue entry carries computed false and says why.
`values[].alternateValues`	array of number	Other published totals for the same string, ascending. Present only where the cipher is not single valued: letter names have several accepted spellings, so several totals are equally published. Absent otherwise, so a caller can branch on presence.
`values[].tradition` required	string	Provenance class of the cipher, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English, so it stays safe to compare against in code.
`values[].source` required	string	The first published source this cipher was taken from.
`values[].name` required	string	Display name of the cipher in the requested language, the same string the ciphers catalogue serves for this id. Present so a caller holding one response can label a row without humanizing the identifier or fetching the catalogue. Switch on id, never on this.
`transformations` required	array of object	The two substitution transformations applied to the chosen spelling. Each exchanges letters and returns a new word, so the interesting output is often the string rather than the number.
`transformations[].id` required	string	Machine identifier of the transformation.
`transformations[].name` required	string	Display name of the transformation as the catalogue names it, in the requested language.
`transformations[].output`	string	The substituted Hebrew string. Absent when atbashOutput asked for the value alone.
`transformations[].outputRomanization`	string	Latin transcription of the substituted string, from the same mechanical letter map.
`transformations[].value`	number	Standard value of the substituted string. Absent when atbashOutput asked for the string alone.
`transformations[].tradition` required	string	Provenance class of the transformation.
`transformations[].source` required	string	The first published source the substitution table was taken from.
`latinValues`	array of object	The Latin alphabet ciphers applied to the Latin text. Present only when latinCiphers was set and a Latin text was sent.
`latinValues[].id` required	string	Machine identifier of the Latin cipher.
`latinValues[].value` required	number	The number this cipher gives for the Latin text as sent.
`latinValues[].tradition` required	string	Provenance class. None of these is rabbinic, whatever a consumer calculator calls them.
`latinValues[].lineage` required	string	Where the cipher comes from, stated so it cannot be misattributed.
`matches` required	array of object	Curated words whose standard value equals the chosen spelling. Matching is on the standard reading only, because that is the relation the classical method works with. Empty when nothing matches, which is the ordinary case.
`matches[].id` required	string	Machine identifier of the entry, an ASCII romanization.
`matches[].hebrew` required	string	The word in Hebrew. Data, identical in every language.
`matches[].romanization` required	string	Latin transcription of the Hebrew beside it, from the same mechanical letter map.
`matches[].meaning` required	string	What the word means, in the requested language.
`matches[].value` required	number	Its value under the standard reading, which is why it matched.
`matches[].note` required	string	What the tradition says about the equality, in the requested language.
`matches[].sources` required	array of string	Where the value is attested. Every entry in the lexicon carries at least two independent sources, which is why the list is short rather than long.
`conventions` required	object
`conventions.transliteration`	string	The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
`conventions.misparGadol` required	string	Which of the two published methods the name mispar gadol was read as.
`conventions.atbashOutput` required	string	What the substitution transformations returned.

Example response

{
  "input": {
    "text": "Sarah",
    "textHebrew": "שלום"
  },
  "hebrewForms": [
    {
      "hebrew": "שרה",
      "romanization": "ShRH",
      "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": 376,
          "alternateValues": [
            527,
            536
          ],
          "tradition": "rabbinic",
          "source": "https://en.wikipedia.org/wiki/Gematria"
        }
      ],
      "letters": [
        {
          "glyph": "ש",
          "letterId": "shin",
          "name": "Shin",
          "isFinal": false,
          "value": 300
        }
      ]
    }
  ],
  "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": 376,
      "alternateValues": [
        527,
        536
      ],
      "tradition": "rabbinic",
      "source": "https://en.wikipedia.org/wiki/Gematria",
      "name": "Mispar hechrachi (absolute value)"
    }
  ],
  "transformations": [
    {
      "id": "atbash",
      "name": "AtBash",
      "output": "בבל",
      "outputRomanization": "BBL",
      "value": 34,
      "tradition": "rabbinic",
      "source": "https://en.wikipedia.org/wiki/Gematria"
    }
  ],
  "latinValues": [
    {
      "id": "simple-ordinal",
      "value": 52,
      "tradition": "renaissance-latin",
      "lineage": "A Latin analogue of Greek isopsephy. Traced through Etienne Tabourot 1583, Pietro Bongo, Georg Philipp Harsdorffer 1651, Athanasius Kircher 1665 and Johann Henning 1683, and called the Alphabetum Cabbalisticum Vulgare by Johann Christoph Maennling 1704 and Christian Friedrich Hunold 1707."
    }
  ],
  "matches": [
    {
      "id": "shalom",
      "hebrew": "שלום",
      "romanization": "ShLVM",
      "meaning": "peace",
      "value": 376,
      "note": "Peace and the name Esau share a value, which the sources treat as a deliberate pairing.",
      "sources": [
        "https://www.sefaria.org/Noam_Elimelekh%2C_Additions%2C_Likutei_Shoshana.61.1"
      ]
    }
  ],
  "conventions": {
    "transliteration": "letter-map-mathers",
    "misparGadol": "finals-500-900",
    "atbashOutput": "both"
  }
}

List gematria ciphers - gematria methods API with provenance on every row

GET /api/v2/kabbalah/ciphers

Return the full catalogue of gematria methods this API computes: eleven rabbinic ciphers, two substitution transformations, and the three Latin alphabet ciphers, each with its definition, its provenance class, the century of its tradition and the sources it was taken from. Every entry states whether it is rabbinic or a Renaissance Christian or modern Latin cipher, so a product never presents one tradition as the other. Built for calculators that want to show a reader which method produced a number and where the method comes from.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.

curl

curl "https://roxyapi.com/api/v2/kabbalah/ciphers" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`total` required	number	Number of entries across all three lists.
`ciphers` required	array of object	The rabbinic ciphers. Each returns a number from the letters of a Hebrew string.
`ciphers[].id` required	string	Machine identifier of the cipher, always English romanization so it stays safe to compare against in code. Pass it in the ciphers array on the gematria endpoint.
`ciphers[].name` required	string	Display name of the cipher, in the requested language.
`ciphers[].tradition` required	string	Provenance class, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English. Read it before presenting a cipher as Jewish practice, because three of the ones here are not.
`ciphers[].century` required	string	The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
`ciphers[].definition` required	string	How the cipher turns letters into a number, in the requested language.
`ciphers[].computed` required	boolean	Whether the gematria endpoint returns a number for this cipher. False on the one method whose table is not published in two independent sources, which is stated rather than silently omitted.
`ciphers[].multiValued`	boolean	Present and true where one spelling has several equally published totals. Absent otherwise, so a caller can branch on presence.
`ciphers[].sources` required	array of string	Where the definition is published. Every cipher here carries at least two independent sources, which is why the catalogue is shorter than the ones that advertise a cipher count.
`transformations` required	array of object	The rabbinic substitution transformations. Each exchanges letters for other letters and returns a WORD, whose value is then read the ordinary way.
`transformations[].id` required	string	Machine identifier of the cipher, always English romanization so it stays safe to compare against in code. Pass it in the ciphers array on the gematria endpoint.
`transformations[].name` required	string	Display name of the cipher, in the requested language.
`transformations[].tradition` required	string	Provenance class, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English. Read it before presenting a cipher as Jewish practice, because three of the ones here are not.

Show all fieldsShow fewer fields

Field	Type	Description
`transformations[].century` required	string	The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
`transformations[].definition` required	string	How the cipher turns letters into a number, in the requested language.
`transformations[].computed` required	boolean	Whether the gematria endpoint returns a number for this cipher. False on the one method whose table is not published in two independent sources, which is stated rather than silently omitted.
`transformations[].multiValued`	boolean	Present and true where one spelling has several equally published totals. Absent otherwise, so a caller can branch on presence.
`transformations[].sources` required	array of string	Where the definition is published. Every cipher here carries at least two independent sources, which is why the catalogue is shorter than the ones that advertise a cipher count.
`latinCiphers` required	array of object	The Latin alphabet ciphers, scored on Latin letters directly. None is rabbinic and each carries the lineage that says so.
`latinCiphers[].id` required	string	Machine identifier of the cipher, always English romanization so it stays safe to compare against in code. Pass it in the ciphers array on the gematria endpoint.
`latinCiphers[].name` required	string	Display name of the cipher, in the requested language.
`latinCiphers[].tradition` required	string	Provenance class, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English. Read it before presenting a cipher as Jewish practice, because three of the ones here are not.
`latinCiphers[].century` required	string	The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
`latinCiphers[].definition` required	string	How the cipher turns letters into a number, in the requested language.
`latinCiphers[].computed` required	boolean	Whether the gematria endpoint returns a number for this cipher. False on the one method whose table is not published in two independent sources, which is stated rather than silently omitted.
`latinCiphers[].multiValued`	boolean	Present and true where one spelling has several equally published totals. Absent otherwise, so a caller can branch on presence.
`latinCiphers[].sources` required	array of string	Where the definition is published. Every cipher here carries at least two independent sources, which is why the catalogue is shorter than the ones that advertise a cipher count.

Example response

{
  "total": 16,
  "ciphers": [
    {
      "id": "mispar-hechrachi",
      "name": "Mispar hechrachi (absolute value)",
      "tradition": "rabbinic",
      "century": "Second century onward",
      "definition": "The standard method. Assigns 1 to 9, 10 to 90, 100 to 400 to the 22 letters in order. Final forms score as their base letter.",
      "computed": true,
      "multiValued": true,
      "sources": [
        "https://en.wikipedia.org/wiki/Gematria"
      ]
    }
  ],
  "transformations": [
    {
      "id": "mispar-hechrachi",
      "name": "Mispar hechrachi (absolute value)",
      "tradition": "rabbinic",
      "century": "Second century onward",
      "definition": "The standard method. Assigns 1 to 9, 10 to 90, 100 to 400 to the 22 letters in order. Final forms score as their base letter.",
      "computed": true,
      "multiValued": true,
      "sources": [
        "https://en.wikipedia.org/wiki/Gematria"
      ]
    }
  ],
  "latinCiphers": [
    {
      "id": "mispar-hechrachi",
      "name": "Mispar hechrachi (absolute value)",
      "tradition": "rabbinic",
      "century": "Second century onward",
      "definition": "The standard method. Assigns 1 to 9, 10 to 90, 100 to 400 to the 22 letters in order. Final forms score as their base letter.",
      "computed": true,
      "multiValued": true,
      "sources": [
        "https://en.wikipedia.org/wiki/Gematria"
      ]
    }
  ]
}

Generate a name profile - Kabbalah name numerology API with the spelling shown

POST /api/v2/kabbalah/name-profile

Score a name across the rabbinic gematria ciphers and place it on the Tree of Life, with every candidate Hebrew spelling shown and the chosen one named. The response carries the standard, the large, the small and the preceding readings with the per letter breakdown, the sephirah the reduced value points at, and the curated words that share the value. Built for name meaning pages, Kabbalah numerology features and any product that wants a name reading it can defend line by line.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.

Request body

Field	Type	Description
`name`	string	The name in Latin script, to be written in Hebrew and then scored. Non Latin scripts are folded to Latin first. Send nameHebrew instead to control the spelling yourself.
`nameHebrew`	string	The name already in Hebrew, which skips the transliteration step entirely and scores exactly the spelling you sent.
`transliteration`	string enum	How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
`misparGadol`	string enum	Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.

curl

curl -X POST "https://roxyapi.com/api/v2/kabbalah/name-profile" \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"Sarah","nameHebrew":"שרה","transliteration":"letter-map-mathers","misparGadol":"finals-500-900"}'

Response fields

Field	Type	Description
`input` required	object
`input.name`	string	Echo of the Latin name sent. Absent when Hebrew was sent instead.
`input.nameHebrew`	string	Echo of the Hebrew name sent. Absent when Latin was sent instead.
`hebrewForms` required	array of object	Every Hebrew spelling the name can be written as, greedy parse first. One entry when Hebrew was sent, since there is nothing to choose.
`hebrewForms[].hebrew` required	string	One Hebrew spelling the Latin input can be written as. Data, identical in every language.
`hebrewForms[].romanization` required	string	Latin transcription of the Hebrew beside it, produced by one mechanical letter map. It is a label for reading the string back, never a pronunciation claim.
`hebrewForms[].rule` required	string	Why this spelling came out of the map: the parse rule first, then one sentence for every reading the scheme applied that the letters alone would not show, so a caller can tell the parses apart.
`hebrewForms[].values` required	array of object	Every computed cipher applied to this spelling, in catalogue order. The rows carry no display name, because they are the same ciphers in the same order for every spelling: read the names off the top level values array once.
`hebrewForms[].values[].id` required	string	Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
`hebrewForms[].values[].value` required	number	The number this cipher gives for the string. Always a number: the one catalogued cipher this API does not compute is absent from this array rather than present without a value, so no row here has to be guarded. Its catalogue entry carries computed false and says why.
`hebrewForms[].values[].alternateValues`	array of number	Other published totals for the same string, ascending. Present only where the cipher is not single valued: letter names have several accepted spellings, so several totals are equally published. Absent otherwise, so a caller can branch on presence.
`hebrewForms[].values[].tradition` required	string	Provenance class of the cipher, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English, so it stays safe to compare against in code.
`hebrewForms[].values[].source` required	string	The first published source this cipher was taken from.
`hebrewForms[].letters` required	array of object	The per letter breakdown of this spelling under the standard reading.

Show all fieldsShow fewer fields

Field	Type	Description
`hebrewForms[].letters[].glyph` required	string	The Hebrew letter as it stands in the string. Data, identical in every language.
`hebrewForms[].letters[].letterId` required	string	Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
`hebrewForms[].letters[].name` required	string	Display name of the letter, in the requested language. Branch on letterId, never on this.
`hebrewForms[].letters[].isFinal` required	boolean	True when the glyph is the word final form. Under the finals-500-900 reading the same letter scores differently in final position, which is why this is on the row.
`hebrewForms[].letters[].value` required	number	What this letter contributed under the standard reading, or under the finals reading when one applies.
`chosen` required	object
`chosen.hebrew` required	string	The spelling the rest of this response was computed from.
`chosen.romanization` required	string	Latin transcription of the chosen spelling, from the mechanical map.
`chosen.rule` required	string	Why this spelling was chosen over the others.
`values` required	object	The four readings a name profile leads with. Call the gematria endpoint for the full set and for the substitution transformations.
`values.standard` required	number	Mispar hechrachi, the standard reading, where every letter takes its ordinary value and a final form scores as its base letter.
`values.large` required	number	Mispar gadol under the reading the misparGadol convention selected, which is why the convention comes back on the response.
`values.small` required	number	Mispar katan, where each letter value has its trailing zeros truncated, so yod is 1 and qof is 1.
`values.preceding` required	number	Mispar kidmi, where each letter scores the sum of every standard value up to and including itself, so tav is 1495.
`letters` required	array of object	The per letter breakdown of the chosen spelling.
`letters[].glyph` required	string	The letter as it stands in the chosen spelling.
`letters[].letterId` required	string	Machine identifier of the letter.
`letters[].name` required	string	Display name of the letter.
`letters[].isFinal` required	boolean	True when the glyph is the word final form.
`letters[].value` required	number	What this letter contributed.
`sephirah` required	object	Where the name lands on the tree. The reduction is a numerical convention, not a rule from any text, and the reading says so.
`sephirah.id` required	string	Machine identifier of the sephirah the reduced value points at.
`sephirah.number` required	numbernull	Its position in the emanation, 1 to 10.
`sephirah.english` required	string	The English gloss of the name, in the requested language.
`sephirah.hebrew` required	string	The name in Hebrew. Data, identical in every language.
`sephirah.reduced` required	number	The standard value reduced by repeated digit sum, stopping at ten so all ten emanations stay reachable.
`sephirah.meaning` required	string	What the emanation is said to hold, in the requested language.
`sephirah.reading` required	string	The composed sentence that places the name on the tree, in the requested language. It states plainly that the reduction is a numerical convention rather than a classical rule.
`matches` required	array of object	Curated words whose standard value equals the name. Empty when nothing matches, which is the ordinary case.
`matches[].id` required	string	Machine identifier of the entry, an ASCII romanization.
`matches[].hebrew` required	string	The word in Hebrew. Data, identical in every language.
`matches[].romanization` required	string	Latin transcription of the Hebrew beside it, from the same mechanical letter map.
`matches[].meaning` required	string	What the word means, in the requested language.
`matches[].value` required	number	Its value under the standard reading, which is why it matched.
`matches[].note` required	string	What the tradition says about the equality, in the requested language.
`matches[].sources` required	array of string	Where the value is attested. Every entry in the lexicon carries at least two independent sources, which is why the list is short rather than long.
`conventions` required	object
`conventions.transliteration`	string	The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
`conventions.misparGadol` required	string	Which of the two published methods the name mispar gadol was read as.

Example response

{
  "input": {
    "name": "Sarah",
    "nameHebrew": "שרה"
  },
  "hebrewForms": [
    {
      "hebrew": "שרה",
      "romanization": "ShRH",
      "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": 376,
          "alternateValues": [
            527,
            536
          ],
          "tradition": "rabbinic",
          "source": "https://en.wikipedia.org/wiki/Gematria"
        }
      ],
      "letters": [
        {
          "glyph": "ש",
          "letterId": "shin",
          "name": "Shin",
          "isFinal": false,
          "value": 300
        }
      ]
    }
  ],
  "chosen": {
    "hebrew": "שרה",
    "romanization": "ShRH",
    "rule": "Longest match first: every two letter group the table prints is read as one Hebrew letter before the single letters are tried."
  },
  "values": {
    "standard": 505,
    "large": 505,
    "small": 10,
    "preceding": 1590
  },
  "letters": [
    {
      "glyph": "ש",
      "letterId": "shin",
      "name": "Shin",
      "isFinal": false,
      "value": 300
    }
  ],
  "sephirah": {
    "id": "malkuth",
    "number": 10,
    "english": "Kingdom",
    "hebrew": "מַלְכוּת",
    "reduced": 10,
    "meaning": "Kingdom, the emanation that receives. It holds no light of its own in the classical reading, and its whole character is what it does with what arrives.",
    "reading": "Reducing the standard value of שרה gives 10, which points at Kingdom on the tree."
  },
  "matches": [
    {
      "id": "shalom",
      "hebrew": "שלום",
      "romanization": "ShLVM",
      "meaning": "peace",
      "value": 376,
      "note": "Peace and the name Esau share a value, which the sources treat as a deliberate pairing.",
      "sources": [
        "https://www.sefaria.org/Noam_Elimelekh%2C_Additions%2C_Likutei_Shoshana.61.1"
      ]
    }
  ],
  "conventions": {
    "transliteration": "letter-map-mathers",
    "misparGadol": "finals-500-900"
  }
}

Generate a birth profile - Hebrew birthday and birth angel API

POST /api/v2/kabbalah/birth-profile

Return the Hebrew date of a birth, the Hebrew birthday that follows it, the three birth names of the Renaissance angel tradition and the sephirah of the birth day, from one birth moment. The Hebrew date is computed from the published calendar algorithm rather than looked up, the sunset boundary is a typed request field because it depends on where you were, and the two rival ways of dating the first name are a typed convention the response echoes. Built for Jewish culture and education apps, birth angel features and any product that wants the Hebrew birthday on the same key as the rest of its readings.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.

Request body

Field	Type	Description
`date` required	string (date)	Birth date in YYYY-MM-DD, proleptic Gregorian. Dates before the 1582 reform are read on the same proleptic reckoning rather than switched to the Julian calendar.
`time`	string (time)	Birth time in HH:MM:SS local to the timezone field. Defaults to noon when omitted, which is stated because the name read from the hour changes every twenty minutes and a defaulted time cannot be precise.
`timezone` required	number or string	IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
`angelDating`	string enum	How the name of the day is found. Use solar-longitude for the exact five degree arc the Sun stood in at the birth moment, or lenain-blocks for the fixed civil calendar of five day periods. The Sun does not move at a constant rate, so the two drift apart by up to about three days by early August and were never reconciled.
`yearStart`	string enum	Which date the civil wheel of five day periods opens on. Both are conventions rather than facts: the equinox itself moves inside a window that covers both days, and it fell on 20 March in 2026. march-21 is the pinned published wheel and march-20 is that wheel shifted one day. Ignored when angelDating is solar-longitude.
`leapDayPolicy`	string enum	Where 29 February falls. The civil wheel was built for a 365 day year and has no slot for it, so published tables differ: extend-previous reads the day as part of the period ending 28 February, next-angel reads it as the opening of the period starting 1 March. Ignored when angelDating is solar-longitude.
`afterSunset`	boolean	Set true when the moment falls after nightfall, which advances the Hebrew date by one day because the Hebrew day begins in the evening. It is a caller assertion rather than a computation, since sunset depends on a place and this conversion takes none.

curl

curl -X POST "https://roxyapi.com/api/v2/kabbalah/birth-profile" \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"1990-06-15","timezone":"America/New_York"}'

Response fields

Field	Type	Description
`birthData` required	object	The birth moment this answer was computed from.
`birthData.date` required	string	Echo of the birth date.
`birthData.time` required	string	The birth time used, which is noon when none was sent.
`birthData.timezone` required	number	The timezone resolved to a decimal offset in hours. An IANA name sent on the request is resolved against the birth date, so a summer birth carries its summer offset.
`hebrewDate` required	object	The Hebrew date of the birth.
`hebrewDate.year` required	number	Hebrew year.
`hebrewDate.month` required	string	Hebrew month name. A leap year carries Adar I and Adar II in place of Adar, which is why the name is returned rather than only a number.
`hebrewDate.monthNumber` required	number	Month number in the published algorithm order, Nisan first. Adar II is 13.
`hebrewDate.day` required	number	Day of the Hebrew month, 1 to 30.
`hebrewDate.leapYear` required	boolean	True in the seven years of each nineteen that carry a second Adar.
`hebrewDate.hebrew` required	string	The date written the way it is printed, with the day and the year in Hebrew letters. Data, identical in every language.
`hebrewDate.afterSunset` required	boolean	Echo of the sunset flag. The Hebrew day begins in the evening, so a moment after nightfall already belongs to the next date and this says whether that was applied.
`hebrewBirthday` required	object	The next Hebrew birthday. Three Hebrew dates are missing from some years, and where the anniversary moves to is a matter of community practice rather than arithmetic, so the field is null with a note rather than a guess.
`hebrewBirthday.date` required	stringnull	The next Gregorian date the Hebrew birthday falls on, or null when that Hebrew date does not exist in the year it would fall in.

Show all fieldsShow fewer fields

Field	Type	Description
`hebrewBirthday.hebrewYear` required	number	The Hebrew year the anniversary was looked for in.
`hebrewBirthday.note`	string	Present only when the date is null, saying why. Absent otherwise, so a caller can branch on presence.
`angels` required	array of object	The three names: two read from the day of birth by two different cycles, and one from the hour. All three are described, never invoked.
`angels[].role` required	string	What this name is read from: body and character both come from the day of birth by two different cycles, and spirit comes from the hour. Always English, so it stays safe to compare against in code.
`angels[].number` required	number	Index of the name, 1 to 72.
`angels[].name` required	string	The name in Hebrew. Data, identical in every language.
`angels[].romanization` required	string	Latin transcription of the Hebrew, from the one mechanical letter map.
`angels[].traditionalName` required	string	The Latin spelling the published tables print, which is the searchable name.
`angels[].choir` required	string	The angelic choir the name belongs to under the published Renaissance table.
`angels[].window` required	string	The window that selected this name, in the terms of its own cycle: an arc of longitude, a span of civil days, or a twenty minute interval of the clock.
`angels[].reading` required	string	What the tradition says this name is read for, in the requested language.
`sephirah` required	object	The sephirah reached from the value of the Hebrew date written in letters. A numerical convention rather than a classical rule, offered as a way into the tree.
`sephirah.id` required	string	Machine identifier of the sephirah of the birth day.
`sephirah.number` required	numbernull	Its position in the emanation, 1 to 10.
`sephirah.english` required	string	The English gloss of the name, in the requested language.
`sephirah.hebrew` required	string	The name in Hebrew. Data, identical in every language.
`sephirah.romanization` required	string	Latin transcription of the Hebrew, from the mechanical letter map.
`sephirah.meaning` required	string	What the emanation is said to hold, in the requested language.
`conventions` required	object	The conventions this answer was computed under, echoed so it can be reproduced.
`conventions.angelDating` required	string	Which construction dated the name of the day.
`conventions.yearStart` required	string	Where the civil wheel opened. Reported even under solar-longitude, where it selects nothing, so a stored response records every input.
`conventions.leapDayPolicy` required	string	Where 29 February was read as falling.
`conventions.afterSunset` required	boolean	Whether the Hebrew date was advanced for nightfall.

Example response

{
  "birthData": {
    "date": "1990-06-15",
    "time": "14:30:00",
    "timezone": 5.5
  },
  "hebrewDate": {
    "year": 5750,
    "month": "Sivan",
    "monthNumber": 3,
    "day": 22,
    "leapYear": false,
    "hebrew": "כ״ב בסיוון תש״נ",
    "afterSunset": false
  },
  "hebrewBirthday": {
    "date": "2026-06-08",
    "hebrewYear": 5786,
    "note": "That Hebrew date does not exist in the target year, so no anniversary is returned. Which day it moves to is a matter of practice and differs between communities."
  },
  "angels": [
    {
      "role": "body",
      "number": 27,
      "name": "ירתאל",
      "romanization": "IRThAL",
      "traditionalName": "Ierathel",
      "choir": "Dominions",
      "window": "130 to 135 degrees of ecliptic longitude, Leo 10 to Leo 15",
      "reading": "The name governing the day of birth. In this lineage it is the first of three, and the tradition reads it as the one attached to the physical circumstances a person is born into."
    }
  ],
  "sephirah": {
    "id": "netzach",
    "number": 7,
    "english": "Endurance",
    "hebrew": "נֶצַח",
    "romanization": "NTzCh",
    "meaning": "Endurance, the impulse that keeps going after the first enthusiasm has gone. It sits low on the right hand pillar, close to where things actually get done."
  },
  "conventions": {
    "angelDating": "solar-longitude",
    "yearStart": "march-21",
    "leapDayPolicy": "extend-previous",
    "afterSunset": false
  }
}

Try it

lang

Request bodyJSON, as the example above shows it.

Not sent

List the 72 names - Shem HaMephorash API derived from the verses

GET /api/v2/kabbalah/names

Return the seventy two names, each with the three letters it is read from, the divine name suffix, the five degree ecliptic arc it governs, the sign that arc falls in and the angelic choir it belongs to. The names are DERIVED from three verses of Exodus read in the boustrophedon order rather than copied from a table, and any row where a named published list differs is flagged on that row. Pass a longitude to get the single name governing that degree. Built for birth angel features, Shem HaMephorash reference pages and any product that has to show where a name comes from.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.
`limit` query	integer	Maximum items to return per page. Range: 1-72, default 20. Default `20`.
`offset` query	integer	Number of items to skip for pagination. Default 0. Default `0`.
`longitude` query	number	Ecliptic longitude in degrees, 0 inclusive to 360 exclusive, measured from 0 Aries. Returns the single name governing that degree instead of the list. 360 is rejected because it is the same point as 0 and the arcs are half open at the top.

curl

curl "https://roxyapi.com/api/v2/kabbalah/names" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`total` required	number	Number of names matching the request before paging, which is 72 for the list and 1 for a longitude lookup.
`limit` required	number	How many rows this page carries at most.
`offset` required	number	How many rows were skipped before this page.
`longitude`	number	Echo of the longitude looked up. Absent when the whole list was requested.
`names` required	array of object
`names[].number` required	number	Index of the name, 1 to 72. The index is the identifier here, because the Latin spellings differ between published tables while the index never does.
`names[].letters` required	string	The three letters read out of the verses, with any word final form written as its base letter, which is how every published list prints them.
`names[].lettersAsWritten` required	string	The three letters exactly as they stand in the verses. Eighteen of the seventy two pick up a word final form because the source letter falls at a word end, and keeping this beside the normalized form is what makes the rule auditable.
`names[].suffix` required	string	The divine name suffix added to make the triplet pronounceable. Forty of the seventy two take one and thirty two take the other.
`names[].name` required	string	The suffixed name in Hebrew. Data, identical in every language.
`names[].romanization` required	string	Latin transcription of the Hebrew, from the one mechanical letter map. A label for reading the string back, and NOT the spelling the published tables print, which is in traditionalName.
`names[].traditionalName` required	string	The Latin spelling the published tables print. This is the search term a reader knows the name by. Several rows have two attested spellings across tables and the one used here is stated on the methodology page.
`names[].arcStart` required	number	First degree of the ecliptic arc this name governs, measured from 0 Aries. Inclusive.
`names[].arcEnd` required	number	Last degree of the arc, EXCLUSIVE. Seventy two arcs of five degrees tile the circle exactly, which only works if the upper bound is exclusive.

Show all fieldsShow fewer fields

Field	Type	Description
`names[].sign` required	string	Which sign the arc falls in. Always English lowercase, so it stays safe to compare against in code. Six names fall in each sign.
`names[].degreeInSign` required	number	Where the arc opens inside its sign, 0 to 25 in steps of five.
`names[].choir` required	string	The angelic choir this name belongs to under the published Renaissance table. Nine choirs of exactly eight names each.
`names[].publishedDisagreement`	object	Present only on the rows where a named published list differs from the derivation. Recorded rather than silently corrected, because a reader comparing two sources deserves to know which one moved. Absent on every other row, so a caller can branch on presence.
`names[].publishedDisagreement.list` required	string	Which published list prints something different on this row.
`names[].publishedDisagreement.prints` required	string	What that list prints, so a caller matching against it can see why.

Example response

{
  "total": 72,
  "limit": 72,
  "offset": 0,
  "longitude": 131.18,
  "names": [
    {
      "number": 27,
      "letters": "ירת",
      "lettersAsWritten": "םום",
      "suffix": "אל",
      "name": "ירתאל",
      "romanization": "IRThAL",
      "traditionalName": "Ierathel",
      "arcStart": 130,
      "arcEnd": 135,
      "sign": "leo",
      "degreeInSign": 10,
      "choir": "Dominions",
      "publishedDisagreement": {
        "list": "a second published list of the seventy two names",
        "prints": "רעה"
      }
    }
  ]
}

Get one of the 72 names - 72 names of God API by index

GET /api/v2/kabbalah/names/{number}

Return one of the seventy two names by its index: the three letters read out of the verses, the exact positions they were read from, the suffixed name, the ecliptic arc it governs, the sign and the choir. The positions are on the response so a reader can check the derivation against the verses rather than trust it. Built for birth angel detail pages and reference features.

Parameters

Parameter	Type	Description
`number` required path	integer	Index of the name, 1 to 72.
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.

curl

curl "https://roxyapi.com/api/v2/kabbalah/names/27" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`number` required	number	Index of the name, 1 to 72. The index is the identifier here, because the Latin spellings differ between published tables while the index never does.
`letters` required	string	The three letters read out of the verses, with any word final form written as its base letter, which is how every published list prints them.
`lettersAsWritten` required	string	The three letters exactly as they stand in the verses. Eighteen of the seventy two pick up a word final form because the source letter falls at a word end, and keeping this beside the normalized form is what makes the rule auditable.
`suffix` required	string	The divine name suffix added to make the triplet pronounceable. Forty of the seventy two take one and thirty two take the other.
`name` required	string	The suffixed name in Hebrew. Data, identical in every language.
`romanization` required	string	Latin transcription of the Hebrew, from the one mechanical letter map. A label for reading the string back, and NOT the spelling the published tables print, which is in traditionalName.
`traditionalName` required	string	The Latin spelling the published tables print. This is the search term a reader knows the name by. Several rows have two attested spellings across tables and the one used here is stated on the methodology page.
`arcStart` required	number	First degree of the ecliptic arc this name governs, measured from 0 Aries. Inclusive.
`arcEnd` required	number	Last degree of the arc, EXCLUSIVE. Seventy two arcs of five degrees tile the circle exactly, which only works if the upper bound is exclusive.
`sign` required	string	Which sign the arc falls in. Always English lowercase, so it stays safe to compare against in code. Six names fall in each sign.
`degreeInSign` required	number	Where the arc opens inside its sign, 0 to 25 in steps of five.
`choir` required	string	The angelic choir this name belongs to under the published Renaissance table. Nine choirs of exactly eight names each.
`publishedDisagreement`	object	Present only on the rows where a named published list differs from the derivation. Recorded rather than silently corrected, because a reader comparing two sources deserves to know which one moved. Absent on every other row, so a caller can branch on presence.
`publishedDisagreement.list` required	string	Which published list prints something different on this row.

Show all fieldsShow fewer fields

Field	Type	Description
`publishedDisagreement.prints` required	string	What that list prints, so a caller matching against it can see why.

Example response

{
  "number": 27,
  "letters": "ירת",
  "lettersAsWritten": "םום",
  "suffix": "אל",
  "name": "ירתאל",
  "romanization": "IRThAL",
  "traditionalName": "Ierathel",
  "arcStart": 130,
  "arcEnd": 135,
  "sign": "leo",
  "degreeInSign": 10,
  "choir": "Dominions",
  "publishedDisagreement": {
    "list": "a second published list of the seventy two names",
    "prints": "רעה"
  }
}

Get the Tree of Life - sephirot and 22 paths API with typed school variants

GET /api/v2/kabbalah/tree

Return the whole Tree of Life in one call: the ten sephirot with their Hebrew, their pillar, their world and their sphere, Daat beside them, the 22 paths with the letter and the tarot trump on each, the four worlds under both mappings that are in circulation, and the lightning flash order. The school splits are typed request parameters rather than hidden defaults, and the response echoes which arrangement and which reading produced it. Built for Tree of Life diagrams, tarot path features and reference pages that need the structure rather than a picture of it.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.
`treeVariant` query	string enum	Which arrangement of the twenty two paths. The 1652 arrangement, in which Malkuth carries three paths, is the only one with a published table that letters every path, so it is the only member. Default `kircher`.
`sephirotSystem` query	string enum	Which reading assigns a sphere to each sephirah. The two were compared row by row and agree on all ten, so the answer is the same either way; the parameter exists so a caller knows which one produced it rather than assuming. Default `classical`.
`letterAttribution` query	string enum	Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author. Default `sefer-yetzirah-gra`.

curl

curl "https://roxyapi.com/api/v2/kabbalah/tree" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`sephirot` required	array of object	The ten emanations in order, with Daat last.
`sephirot[].id` required	string	Machine identifier of the sephirah, an ASCII romanization, always English so it stays safe to compare against in code. Several romanizations of each name are in circulation and none is canonical, which is exactly why the id is fixed here.
`sephirot[].number` required	numbernull	Position in the emanation, 1 to 10. Null for Daat, which is counted in some diagrams and left out of others and is never an eleventh emanation.
`sephirot[].hebrew` required	string	The name in Hebrew, with vowel points. Data, identical in every language.
`sephirot[].romanization` required	string	Latin transcription of the Hebrew beside it, from the one mechanical letter map. A label for reading the string back, never a pronunciation claim and not the same thing as the id.
`sephirot[].english` required	string	The English gloss of the name, in the requested language.
`sephirot[].pillar` required	string	Which of the three pillars the sephirah stands on: left, middle or right. Always English.
`sephirot[].pillarName` required	string	Display name of the pillar, in the requested language.
`sephirot[].world` required	stringnull	Which of the four worlds the sephirah belongs to under the Hermetic mapping. Null for Daat. A second mapping is in circulation and both are returned in the worlds block.
`sephirot[].attribution` required	string	The sphere assigned to the sephirah under the requested system, in the requested language. This is the sephirot allotment and it is NOT the planet series the seven double letters carry.
`sephirot[].meaning` required	string	What the emanation is said to hold, in the requested language.
`paths` required	array of object	The 22 paths, in path order.
`paths[].path` required	number	Path number, 11 to 32. The numbering continues the ten sephirot into the thirty two Paths of Wisdom, so path 11 is the eleventh Path and not the eleventh path.
`paths[].letter` required	string	Machine identifier of the letter on the path. Each of the 22 appears exactly once.

Show all fieldsShow fewer fields

Field	Type	Description
`paths[].letterGlyph` required	string	The letter itself. Data, identical in every language.
`paths[].from` required	string	Machine identifier of the sephirah the path runs from.
`paths[].to` required	string	Machine identifier of the sephirah the path runs to.
`paths[].trump` required	object
`paths[].trump.id` required	string	Identifier of the tarot trump on this path. It resolves in the Tarot API on the same key.
`paths[].trump.number` required	string	The trump number as the deck prints it.
`paths[].trump.name` required	string	Display name of the trump.
`paths[].attribution` required	object
`paths[].attribution.kind` required	string	What the letter attribution names: element, planet or sign.
`paths[].attribution.value` required	string	The element, planet or sign under the requested reading. Always English.
`worlds` required	array of object	The four worlds, with both published mappings of the sephirot onto them.
`worlds[].id` required	string	Machine identifier of the world, an ASCII romanization.
`worlds[].hebrew` required	string	The name in Hebrew. Data, identical in every language.
`worlds[].romanization` required	string	Latin transcription of the Hebrew, from the mechanical letter map.
`worlds[].english` required	string	The English gloss, in the requested language.
`worlds[].sephirot` required	array of string	Which sephirot fall in this world under the Hermetic mapping, the one the world field on each sephirah uses.
`worlds[].sephirotAlternate` required	array of string	Which sephirot fall in this world under the second mapping in circulation. The two agree on Formation and Action and differ at the top, and neither is suppressed.
`lightningFlash` required	array of string	The order the emanation descends, top to bottom. Ten identifiers, no repeats.
`conventions` required	object	The conventions this answer was computed under, echoed so it can be reproduced.
`conventions.treeVariant` required	string	Which arrangement of the paths produced this answer.
`conventions.sephirotSystem` required	string	Which reading assigned the spheres.
`conventions.letterAttribution` required	string	Which reading assigned the element, planet or sign on each path.

Example response

{
  "sephirot": [
    {
      "id": "tiferet",
      "number": 6,
      "hebrew": "תִּפְאֶרֶת",
      "romanization": "ThPARTh",
      "english": "Beauty",
      "pillar": "middle",
      "pillarName": "Pillar of Equilibrium",
      "world": "Yetzirah",
      "attribution": "Shemesh, the Sun",
      "meaning": "Beauty, the centre of the tree, where the giving side and the withholding side are held in one place. More paths meet here than anywhere else, which is the structure saying what the texts say."
    }
  ],
  "paths": [
    {
      "path": 32,
      "letter": "tav",
      "letterGlyph": "ת",
      "from": "yesod",
      "to": "malkuth",
      "trump": {
        "id": "world",
        "number": "XXI",
        "name": "The World"
      },
      "attribution": {
        "kind": "planet",
        "value": "jupiter"
      }
    }
  ],
  "worlds": [
    {
      "id": "yetzirah",
      "hebrew": "יְצִירָה",
      "romanization": "ITzIRH",
      "english": "Formation",
      "sephirot": [
        "chesed",
        "gevurah"
      ],
      "sephirotAlternate": [
        "chesed",
        "gevurah"
      ]
    }
  ],
  "lightningFlash": [
    "keter",
    "chokhmah"
  ],
  "conventions": {
    "treeVariant": "kircher",
    "sephirotSystem": "classical",
    "letterAttribution": "sefer-yetzirah-gra"
  }
}

Get one sephirah - sefirot meaning API with the paths that touch it

GET /api/v2/kabbalah/sephirot/{id}

Return one sephirah in full: its Hebrew and English names, its pillar, its world, the sphere it carries under the requested system, what the emanation is said to hold, and every path that touches it with the letter and the tarot trump on each. Daat is addressable here as well, and its response says plainly that it is counted in some diagrams and not in others. Built for sephirot detail pages and for tree diagrams that load one node at a time.

Parameters

Parameter	Type	Description
`id` required path	string enum	Sephirah identifier, one of keter, chokhmah, binah, chesed, gevurah, tiferet, netzach, hod, yesod, malkuth, daat. Matching folds case and punctuation.
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.
`sephirotSystem` query	string enum	Which reading assigns a sphere to each sephirah. The two were compared row by row and agree on all ten, so the answer is the same either way; the parameter exists so a caller knows which one produced it rather than assuming. Default `classical`.
`letterAttribution` query	string enum	Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author. Default `sefer-yetzirah-gra`.

curl

curl "https://roxyapi.com/api/v2/kabbalah/sephirot/tiferet" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`id` required	string	Machine identifier of the sephirah, an ASCII romanization, always English so it stays safe to compare against in code. Several romanizations of each name are in circulation and none is canonical, which is exactly why the id is fixed here.
`number` required	numbernull	Position in the emanation, 1 to 10. Null for Daat, which is counted in some diagrams and left out of others and is never an eleventh emanation.
`hebrew` required	string	The name in Hebrew, with vowel points. Data, identical in every language.
`romanization` required	string	Latin transcription of the Hebrew beside it, from the one mechanical letter map. A label for reading the string back, never a pronunciation claim and not the same thing as the id.
`english` required	string	The English gloss of the name, in the requested language.
`pillar` required	string	Which of the three pillars the sephirah stands on: left, middle or right. Always English.
`pillarName` required	string	Display name of the pillar, in the requested language.
`world` required	stringnull	Which of the four worlds the sephirah belongs to under the Hermetic mapping. Null for Daat. A second mapping is in circulation and both are returned in the worlds block.
`attribution` required	string	The sphere assigned to the sephirah under the requested system, in the requested language. This is the sephirot allotment and it is NOT the planet series the seven double letters carry.
`meaning` required	string	What the emanation is said to hold, in the requested language.
`paths` required	array of object	Every path that runs to or from this sephirah, in path order. Malkuth carries three under the arrangement this API ships, which is the whole difference between the two arrangements in circulation.
`paths[].path` required	number	Path number, 11 to 32. The numbering continues the ten sephirot into the thirty two Paths of Wisdom, so path 11 is the eleventh Path and not the eleventh path.
`paths[].letter` required	string	Machine identifier of the letter on the path. Each of the 22 appears exactly once.
`paths[].letterGlyph` required	string	The letter itself. Data, identical in every language.

Show all fieldsShow fewer fields

Field	Type	Description
`paths[].from` required	string	Machine identifier of the sephirah the path runs from.
`paths[].to` required	string	Machine identifier of the sephirah the path runs to.
`paths[].trump` required	object
`paths[].trump.id` required	string	Identifier of the tarot trump on this path. It resolves in the Tarot API on the same key.
`paths[].trump.number` required	string	The trump number as the deck prints it.
`paths[].trump.name` required	string	Display name of the trump.
`paths[].attribution` required	object
`paths[].attribution.kind` required	string	What the letter attribution names: element, planet or sign.
`paths[].attribution.value` required	string	The element, planet or sign under the requested reading. Always English.
`conventions` required	object	The conventions this answer was computed under.
`conventions.sephirotSystem` required	string	Which reading assigned the sphere.
`conventions.letterAttribution` required	string	Which reading assigned the element, planet or sign on each path.

Example response

{
  "id": "tiferet",
  "number": 6,
  "hebrew": "תִּפְאֶרֶת",
  "romanization": "ThPARTh",
  "english": "Beauty",
  "pillar": "middle",
  "pillarName": "Pillar of Equilibrium",
  "world": "Yetzirah",
  "attribution": "Shemesh, the Sun",
  "meaning": "Beauty, the centre of the tree, where the giving side and the withholding side are held in one place. More paths meet here than anywhere else, which is the structure saying what the texts say.",
  "paths": [
    {
      "path": 32,
      "letter": "tav",
      "letterGlyph": "ת",
      "from": "yesod",
      "to": "malkuth",
      "trump": {
        "id": "world",
        "number": "XXI",
        "name": "The World"
      },
      "attribution": {
        "kind": "planet",
        "value": "jupiter"
      }
    }
  ],
  "conventions": {
    "sephirotSystem": "classical",
    "letterAttribution": "sefer-yetzirah-gra"
  }
}

List the Hebrew letters - Hebrew alphabet API with the Sefer Yetzirah attributions

GET /api/v2/kabbalah/letters

Return all 22 Hebrew letters with their numeric value, their final form, their Sefer Yetzirah class, the element or planet or sign they carry under the requested reading, the tarot trump on their path and the path number itself. The letter attributions are a documented school split rather than a fixed table, so the reading is a request parameter and the response echoes which one produced the answer. Built for letter reference pages, tarot apps that render the paths, and any feature that has to say what a letter carries and on whose authority.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.
`letterAttribution` query	string enum	Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author. Default `sefer-yetzirah-gra`.

curl

curl "https://roxyapi.com/api/v2/kabbalah/letters" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`total` required	number	Number of letters returned, which is always 22.
`letterAttribution` required	string	Echo of the reading the attributions were taken from.
`classCounts` required	object	Three, seven and twelve. Every recension agrees on the split even where it disagrees on what goes where.
`classCounts.mother` required	number	Mother letters, which take an element.
`classCounts.double` required	number	Double letters, which take a planet.
`classCounts.simple` required	number	Simple letters, which take a sign of the zodiac.
`letters` required	array of object
`letters[].id` required	string	Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
`letters[].letter` required	string	The base glyph. Data, identical in every language.
`letters[].final` required	stringnull	The word final glyph, or null for the seventeen letters that have none. Five letters change shape at the end of a word and score differently there under one reading of mispar gadol.
`letters[].romanization` required	string	Latin transcription of the glyph, from the one mechanical letter map this API uses in both directions. A label, never a pronunciation claim.
`letters[].name` required	string	Display name of the letter, in the requested language.
`letters[].meaning` required	string	What the letter name means as an ordinary word, in the requested language. The names are object names, which is what the shapes were drawn from.
`letters[].ordinal` required	number	Position in the alphabet, 1 to 22. A property of the letter, not a cipher reading.

Show all fieldsShow fewer fields

Field	Type	Description
`letters[].value` required	number	Value under the standard reading. The 22 letters cover 1 to 9, 10 to 90 and 100 to 400.
`letters[].finalValue` required	numbernull	Value in final position under the finals-500-900 reading of mispar gadol, or null where the letter has no final form.
`letters[].letterClass` required	string	Sefer Yetzirah class: mother, double or simple. Three mothers take an element, seven doubles take a planet, twelve simples take a sign, and the three counts are the structure of the whole letter tradition.
`letters[].classReading` required	string	What the class means, in the requested language.
`letters[].attribution` required	object
`letters[].attribution.kind` required	string	What the attribution names: element, planet or sign. Always English.
`letters[].attribution.value` required	string	The element, planet or sign under the requested reading. Always English, so it stays safe to compare against in code.
`letters[].trump` required	object
`letters[].trump.id` required	string	Identifier of the tarot trump on this letter path. It resolves in the Tarot API on the same key, so a caller can follow it straight to the card.
`letters[].trump.number` required	string	The trump number as the deck prints it, in Roman numerals.
`letters[].trump.name` required	string	Display name of the trump.
`letters[].path` required	numbernull	The path this letter sits on, numbered 11 to 32 to continue the ten sephirot into the thirty two Paths of Wisdom. Never null in practice: all 22 letters carry a path.

Example response

{
  "total": 22,
  "letterAttribution": "sefer-yetzirah-gra",
  "classCounts": {
    "mother": 3,
    "double": 7,
    "simple": 12
  },
  "letters": [
    {
      "id": "shin",
      "letter": "ש",
      "final": "ם",
      "romanization": "Sh",
      "name": "Shin",
      "meaning": "Tooth",
      "ordinal": 21,
      "value": 300,
      "finalValue": 900,
      "letterClass": "mother",
      "classReading": "One of the three mother letters. The Sefer Yetzirah gives each of the three an element, and they are the top of the letter hierarchy rather than one class among many.",
      "attribution": {
        "kind": "element",
        "value": "fire"
      },
      "trump": {
        "id": "judgement",
        "number": "XX",
        "name": "Judgement"
      },
      "path": 31
    }
  ]
}

Get one Hebrew letter - Hebrew letter meaning API

GET /api/v2/kabbalah/letters/{id}

Return one Hebrew letter in full: its glyph and final form, its value under the standard and the finals reading, its Sefer Yetzirah class and what that class means, the element or planet or sign it carries under the requested reading, the tarot trump on its path, and the path number. Built for letter detail pages and for any reader who wants one row rather than all 22 letters.

Parameters

Parameter	Type	Description
`id` required path	string enum	Letter identifier, one of alef, bet, gimel, dalet, he, vav, zayin, chet, tet, yod, kaf, lamed, mem, nun, samekh, ayin, pe, tzadi, qof, resh, shin, tav. Matching folds case and punctuation.
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.
`letterAttribution` query	string enum	Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author. Default `sefer-yetzirah-gra`.

curl

curl "https://roxyapi.com/api/v2/kabbalah/letters/shin" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`id` required	string	Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
`letter` required	string	The base glyph. Data, identical in every language.
`final` required	stringnull	The word final glyph, or null for the seventeen letters that have none. Five letters change shape at the end of a word and score differently there under one reading of mispar gadol.
`romanization` required	string	Latin transcription of the glyph, from the one mechanical letter map this API uses in both directions. A label, never a pronunciation claim.
`name` required	string	Display name of the letter, in the requested language.
`meaning` required	string	What the letter name means as an ordinary word, in the requested language. The names are object names, which is what the shapes were drawn from.
`ordinal` required	number	Position in the alphabet, 1 to 22. A property of the letter, not a cipher reading.
`value` required	number	Value under the standard reading. The 22 letters cover 1 to 9, 10 to 90 and 100 to 400.
`finalValue` required	numbernull	Value in final position under the finals-500-900 reading of mispar gadol, or null where the letter has no final form.
`letterClass` required	string	Sefer Yetzirah class: mother, double or simple. Three mothers take an element, seven doubles take a planet, twelve simples take a sign, and the three counts are the structure of the whole letter tradition.
`classReading` required	string	What the class means, in the requested language.
`attribution` required	object
`attribution.kind` required	string	What the attribution names: element, planet or sign. Always English.
`attribution.value` required	string	The element, planet or sign under the requested reading. Always English, so it stays safe to compare against in code.

Show all fieldsShow fewer fields

Field	Type	Description
`trump` required	object
`trump.id` required	string	Identifier of the tarot trump on this letter path. It resolves in the Tarot API on the same key, so a caller can follow it straight to the card.
`trump.number` required	string	The trump number as the deck prints it, in Roman numerals.
`trump.name` required	string	Display name of the trump.
`path` required	numbernull	The path this letter sits on, numbered 11 to 32 to continue the ten sephirot into the thirty two Paths of Wisdom. Never null in practice: all 22 letters carry a path.

Example response

{
  "id": "shin",
  "letter": "ש",
  "final": "ם",
  "romanization": "Sh",
  "name": "Shin",
  "meaning": "Tooth",
  "ordinal": 21,
  "value": 300,
  "finalValue": 900,
  "letterClass": "mother",
  "classReading": "One of the three mother letters. The Sefer Yetzirah gives each of the three an element, and they are the top of the letter hierarchy rather than one class among many.",
  "attribution": {
    "kind": "element",
    "value": "fire"
  },
  "trump": {
    "id": "judgement",
    "number": "XX",
    "name": "Judgement"
  },
  "path": 31
}

Compare two names - gematria name compatibility API with every component published

POST /api/v2/kabbalah/compatibility

Score two names against each other in gematria and return both profiles, the ciphers they agree on, and a composite with every component and its maximum published beside it. Equal value under the standard reading is the one relation the classical method actually works with and it carries the largest weight; the rest of the composite is ours and the response says so, so a caller can recompute or ignore it. Built for name compatibility features, relationship content and any product that wants a number it can show the arithmetic for.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.

Request body

Field	Type	Description
`firstName`	string	First name in Latin script. Send firstNameHebrew instead to control the spelling.
`firstNameHebrew`	string	First name already in Hebrew, which skips the transliteration step.
`secondName`	string	Second name in Latin script. Send secondNameHebrew instead to control the spelling.
`secondNameHebrew`	string	Second name already in Hebrew, which skips the transliteration step.
`transliteration`	string enum	How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
`misparGadol`	string enum	Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.

curl

curl -X POST "https://roxyapi.com/api/v2/kabbalah/compatibility" \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"firstName":"Sarah","firstNameHebrew":"שרה","secondName":"David","secondNameHebrew":"דוד"}'

Response fields

Field	Type	Description
`first` required	object
`first.input` required	string	The name as sent, in whichever script it was sent in.
`first.hebrew` required	string	The Hebrew spelling this side was scored from.
`first.romanization` required	string	Latin transcription of that spelling, from the one mechanical letter map.
`first.rule` required	string	Why this spelling was chosen over the other parses.
`first.standard` required	number	Value under the standard reading, which is the relation the tradition works with.
`first.reduced` required	number	The standard value reduced by repeated digit sum, stopping at ten.
`first.sephirah` required	string	Machine identifier of the sephirah the reduced value points at.
`first.sephirahEnglish` required	string	The English gloss of that sephirah, in the requested language.
`second` required	object
`second.input` required	string	The name as sent, in whichever script it was sent in.
`second.hebrew` required	string	The Hebrew spelling this side was scored from.
`second.romanization` required	string	Latin transcription of that spelling, from the one mechanical letter map.
`second.rule` required	string	Why this spelling was chosen over the other parses.

Show all fieldsShow fewer fields

Field	Type	Description
`second.standard` required	number	Value under the standard reading, which is the relation the tradition works with.
`second.reduced` required	number	The standard value reduced by repeated digit sum, stopping at ten.
`second.sephirah` required	string	Machine identifier of the sephirah the reduced value points at.
`second.sephirahEnglish` required	string	The English gloss of that sephirah, in the requested language.
`sharedValues` required	array of object	Every cipher on which the two names give the same number. Empty when they share none, which happens often and carries no traditional reading of its own.
`sharedValues[].cipher` required	string	Machine identifier of the cipher the two names agree on.
`sharedValues[].name` required	string	Display name of that cipher.
`sharedValues[].value` required	number	The value both names give under it.
`score` required	number	The composite, 0 to 100. A RoxyAPI composite, not a classical measure: no source scores two names against each other, so the components below are published and the number is derivable from them.
`band` required	string	Which band the composite falls in: high, moderate or low. Derived from the score, always English.
`components` required	array of object	Every component of the composite with its own maximum, so a caller who disagrees with the weighting can recompute rather than argue.
`components[].id` required	string	Machine identifier of the component.
`components[].points` required	number	What this component contributed.
`components[].maximum` required	number	The most it can contribute. The four maxima sum to 100, so the weighting is visible rather than implied.
`components[].matched` required	boolean	Whether the component found anything at all.
`reading` required	string	The composed reading, in the requested language. It states that the score is ours.
`conventions` required	object
`conventions.transliteration`	string	The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
`conventions.misparGadol` required	string	Which of the two published methods the name mispar gadol was read as.

Example response

{
  "first": {
    "input": "Sarah",
    "hebrew": "שרה",
    "romanization": "ShRH",
    "rule": "Longest match first: every two letter group the table prints is read as one Hebrew letter before the single letters are tried.",
    "standard": 505,
    "reduced": 10,
    "sephirah": "malkuth",
    "sephirahEnglish": "Kingdom"
  },
  "second": {
    "input": "Sarah",
    "hebrew": "שרה",
    "romanization": "ShRH",
    "rule": "Longest match first: every two letter group the table prints is read as one Hebrew letter before the single letters are tried.",
    "standard": 505,
    "reduced": 10,
    "sephirah": "malkuth",
    "sephirahEnglish": "Kingdom"
  },
  "sharedValues": [
    {
      "cipher": "mispar-katan",
      "name": "Mispar katan (small value)",
      "value": 10
    }
  ],
  "score": 45,
  "band": "moderate",
  "components": [
    {
      "id": "equalStandardValue",
      "points": 35,
      "maximum": 35,
      "matched": true
    }
  ],
  "reading": "The two names meet on some readings and part on others, which is the ordinary case rather than a middling result.",
  "conventions": {
    "transliteration": "letter-map-mathers",
    "misparGadol": "finals-500-900"
  }
}

Get the sephirah of the day - Omer count API with the sephirot pairing

GET /api/v2/kabbalah/daily

Return the day of the Omer count for a date, with the sephirah of the week, the sephirah of the day inside it, the printed Hebrew label and a composed reading. The count is a real, dated, forty nine day observance rather than an invented daily, so outside the window the response says the count is not running and gives the date it next opens. Built for daily widgets, Jewish calendar features and lifecycle emails that want a dated reading rather than a random one.

Parameters

Parameter	Type	Description
`lang` query	string enum	Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English. Default `en`.
`date` query	string (date)	Date in YYYY-MM-DD. Defaults to the current UTC date when omitted, so a caller that wants a fixed answer should send one.
`timezone` query	string	IANA name or decimal offset, used only to decide which calendar date it is where the caller is when date is omitted. It does not move the count, which is a calendar count rather than a clock one.
`afterSunset` query	string	Set true when the moment falls after nightfall, which advances the Hebrew date by one day because the Hebrew day begins in the evening. It is a caller assertion rather than a computation, since sunset depends on a place and this route takes none.

curl

curl "https://roxyapi.com/api/v2/kabbalah/daily" \
  -H "X-API-Key: YOUR_KEY"

Response fields

Field	Type	Description
`date` required	string	The date this answer is for. Echoes the request or the resolved date.
`inOmer` required	boolean	Whether the count is running on this date. False outside the forty nine days, and the fields below the count are then absent.
`day`	number	Day of the count, 1 to 49. Absent when the count is not running.
`week`	number	Which of the seven weeks the day falls in. Absent outside the count.
`dayInWeek`	number	Which day inside that week, 1 to 7. Absent outside the count.
`weekSephirah`	object	The sephirah of the WEEK, which is the outer half of the label. Absent outside the count.
`weekSephirah.id` required	string	Machine identifier of the sephirah, always English so it stays safe to compare against in code.
`weekSephirah.hebrew` required	string	The name in Hebrew, unpointed. Data, identical in every language.
`weekSephirah.romanization` required	string	Latin transcription of the Hebrew, from the one mechanical letter map.
`weekSephirah.english` required	string	The English gloss of the name, in the requested language.
`daySephirah`	object	The sephirah of the DAY inside the week, which is the inner half of the label and is named first. Absent outside the count.
`daySephirah.id` required	string	Machine identifier of the sephirah, always English so it stays safe to compare against in code.
`daySephirah.hebrew` required	string	The name in Hebrew, unpointed. Data, identical in every language.
`daySephirah.romanization` required	string	Latin transcription of the Hebrew, from the one mechanical letter map.

Show all fieldsShow fewer fields

Field	Type	Description
`daySephirah.english` required	string	The English gloss of the name, in the requested language.
`hebrewLabel`	string	The label as the printed text carries it, inner then outer. Absent outside the count.
`hebrewDate`	string	The Hebrew month and day of this Omer day. Day 1 is 16 Nisan, the second day of Passover, on the reckoning this API uses. Absent outside the count.
`reading` required	string	The composed reading for the day, in the requested language.
`nextStart`	string	The date the count next opens. Present only when the count is not running, so a caller can branch on presence.

Example response

{
  "date": "2026-04-04",
  "inOmer": true,
  "day": 1,
  "week": 1,
  "dayInWeek": 1,
  "weekSephirah": {
    "id": "chesed",
    "hebrew": "חסד",
    "romanization": "ChSD",
    "english": "Mercy"
  },
  "daySephirah": {
    "id": "chesed",
    "hebrew": "חסד",
    "romanization": "ChSD",
    "english": "Mercy"
  },
  "hebrewLabel": "חסד שבחסד",
  "hebrewDate": "Nisan 16",
  "reading": "Day 1 of the count falls in week 1, so the week opens a hand and keeps it open and the day inside it opens a hand and keeps it open.",
  "nextStart": "2027-04-22"
}