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

## Calculate gematria - Hebrew gematria calculator API with every spelling shown

`POST https://roxyapi.com/api/v2/kabbalah/gematria`. MCP tool `post_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.

### Request

- `lang` (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.
- `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.

### Response

- `input` (object, required): 
- `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` (array of object, required): 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` (string, required): One Hebrew spelling the Latin input can be written as. Data, identical in every language.
- `hebrewForms[].romanization` (string, required): 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` (string, required): 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` (array of object, required): 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` (string, required): Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
- `hebrewForms[].values[].value` (number, required): 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` (string, required): 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` (string, required): The first published source this cipher was taken from.
- `hebrewForms[].letters` (array of object, required): The per letter breakdown of this spelling under the standard reading.
- `hebrewForms[].letters[].glyph` (string, required): The Hebrew letter as it stands in the string. Data, identical in every language.
- `hebrewForms[].letters[].letterId` (string, required): Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
- `hebrewForms[].letters[].name` (string, required): Display name of the letter, in the requested language. Branch on letterId, never on this.
- `hebrewForms[].letters[].isFinal` (boolean, required): 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` (number, required): What this letter contributed under the standard reading, or under the finals reading when one applies.
- `chosen` (object, required): 
- `chosen.hebrew` (string, required): The spelling the values and matches on this response were taken from.
- `chosen.rule` (string, required): Why this spelling was chosen over the others.
- `values` (array of object, required): 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` (string, required): Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
- `values[].value` (number, required): 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` (string, required): 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` (string, required): The first published source this cipher was taken from.
- `values[].name` (string, required): 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` (array of object, required): 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` (string, required): Machine identifier of the transformation.
- `transformations[].name` (string, required): 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` (string, required): Provenance class of the transformation.
- `transformations[].source` (string, required): 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` (string, required): Machine identifier of the Latin cipher.
- `latinValues[].value` (number, required): The number this cipher gives for the Latin text as sent.
- `latinValues[].tradition` (string, required): Provenance class. None of these is rabbinic, whatever a consumer calculator calls them.
- `latinValues[].lineage` (string, required): Where the cipher comes from, stated so it cannot be misattributed.
- `matches` (array of object, required): 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` (string, required): Machine identifier of the entry, an ASCII romanization.
- `matches[].hebrew` (string, required): The word in Hebrew. Data, identical in every language.
- `matches[].romanization` (string, required): Latin transcription of the Hebrew beside it, from the same mechanical letter map.
- `matches[].meaning` (string, required): What the word means, in the requested language.
- `matches[].value` (number, required): Its value under the standard reading, which is why it matched.
- `matches[].note` (string, required): What the tradition says about the equality, in the requested language.
- `matches[].sources` (array of string, required): 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` (object, required): 
- `conventions.transliteration` (string): The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
- `conventions.misparGadol` (string, required): Which of the two published methods the name mispar gadol was read as.
- `conventions.atbashOutput` (string, required): What the substitution transformations returned.

### Example request

```bash
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"]}'
```

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/ciphers`. MCP tool `get_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.

### Request

- `lang` (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.

### Response

- `total` (number, required): Number of entries across all three lists.
- `ciphers` (array of object, required): The rabbinic ciphers. Each returns a number from the letters of a Hebrew string.
- `ciphers[].id` (string, required): 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` (string, required): Display name of the cipher, in the requested language.
- `ciphers[].tradition` (string, required): 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` (string, required): The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
- `ciphers[].definition` (string, required): How the cipher turns letters into a number, in the requested language.
- `ciphers[].computed` (boolean, required): 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` (array of string, required): 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` (array of object, required): The rabbinic substitution transformations. Each exchanges letters for other letters and returns a WORD, whose value is then read the ordinary way.
- `transformations[].id` (string, required): 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` (string, required): Display name of the cipher, in the requested language.
- `transformations[].tradition` (string, required): 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.
- `transformations[].century` (string, required): The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
- `transformations[].definition` (string, required): How the cipher turns letters into a number, in the requested language.
- `transformations[].computed` (boolean, required): 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` (array of string, required): 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` (array of object, required): The Latin alphabet ciphers, scored on Latin letters directly. None is rabbinic and each carries the lineage that says so.
- `latinCiphers[].id` (string, required): 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` (string, required): Display name of the cipher, in the requested language.
- `latinCiphers[].tradition` (string, required): 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` (string, required): The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
- `latinCiphers[].definition` (string, required): How the cipher turns letters into a number, in the requested language.
- `latinCiphers[].computed` (boolean, required): 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` (array of string, required): 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 request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/name-profile`. MCP tool `post_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.

### Request

- `lang` (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.
- `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.

### Response

- `input` (object, required): 
- `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` (array of object, required): 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` (string, required): One Hebrew spelling the Latin input can be written as. Data, identical in every language.
- `hebrewForms[].romanization` (string, required): 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` (string, required): 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` (array of object, required): 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` (string, required): Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
- `hebrewForms[].values[].value` (number, required): 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` (string, required): 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` (string, required): The first published source this cipher was taken from.
- `hebrewForms[].letters` (array of object, required): The per letter breakdown of this spelling under the standard reading.
- `hebrewForms[].letters[].glyph` (string, required): The Hebrew letter as it stands in the string. Data, identical in every language.
- `hebrewForms[].letters[].letterId` (string, required): Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
- `hebrewForms[].letters[].name` (string, required): Display name of the letter, in the requested language. Branch on letterId, never on this.
- `hebrewForms[].letters[].isFinal` (boolean, required): 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` (number, required): What this letter contributed under the standard reading, or under the finals reading when one applies.
- `chosen` (object, required): 
- `chosen.hebrew` (string, required): The spelling the rest of this response was computed from.
- `chosen.romanization` (string, required): Latin transcription of the chosen spelling, from the mechanical map.
- `chosen.rule` (string, required): Why this spelling was chosen over the others.
- `values` (object, required): The four readings a name profile leads with. Call the gematria endpoint for the full set and for the substitution transformations.
- `values.standard` (number, required): Mispar hechrachi, the standard reading, where every letter takes its ordinary value and a final form scores as its base letter.
- `values.large` (number, required): Mispar gadol under the reading the misparGadol convention selected, which is why the convention comes back on the response.
- `values.small` (number, required): Mispar katan, where each letter value has its trailing zeros truncated, so yod is 1 and qof is 1.
- `values.preceding` (number, required): Mispar kidmi, where each letter scores the sum of every standard value up to and including itself, so tav is 1495.
- `letters` (array of object, required): The per letter breakdown of the chosen spelling.
- `letters[].glyph` (string, required): The letter as it stands in the chosen spelling.
- `letters[].letterId` (string, required): Machine identifier of the letter.
- `letters[].name` (string, required): Display name of the letter.
- `letters[].isFinal` (boolean, required): True when the glyph is the word final form.
- `letters[].value` (number, required): What this letter contributed.
- `sephirah` (object, required): 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` (string, required): Machine identifier of the sephirah the reduced value points at.
- `sephirah.number` (number,null, required): Its position in the emanation, 1 to 10.
- `sephirah.english` (string, required): The English gloss of the name, in the requested language.
- `sephirah.hebrew` (string, required): The name in Hebrew. Data, identical in every language.
- `sephirah.reduced` (number, required): The standard value reduced by repeated digit sum, stopping at ten so all ten emanations stay reachable.
- `sephirah.meaning` (string, required): What the emanation is said to hold, in the requested language.
- `sephirah.reading` (string, required): 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` (array of object, required): Curated words whose standard value equals the name. Empty when nothing matches, which is the ordinary case.
- `matches[].id` (string, required): Machine identifier of the entry, an ASCII romanization.
- `matches[].hebrew` (string, required): The word in Hebrew. Data, identical in every language.
- `matches[].romanization` (string, required): Latin transcription of the Hebrew beside it, from the same mechanical letter map.
- `matches[].meaning` (string, required): What the word means, in the requested language.
- `matches[].value` (number, required): Its value under the standard reading, which is why it matched.
- `matches[].note` (string, required): What the tradition says about the equality, in the requested language.
- `matches[].sources` (array of string, required): 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` (object, required): 
- `conventions.transliteration` (string): The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
- `conventions.misparGadol` (string, required): Which of the two published methods the name mispar gadol was read as.

### Example request

```bash
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"}'
```

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/birth-profile`. MCP tool `post_kabbalah_birth_profile`.

Return the Hebrew date of a birth, the next Hebrew birthday from targetDate or today, 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.

### Request

- `lang` (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.
- `date` (string (date), required): 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` (number or string, required): 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.
- `targetDate` (string (date)): Date to count the next Hebrew birthday from, in YYYY-MM-DD format. Send the local date of the user for an exact answer: on the birthday itself the answer is that day. Defaults to today (UTC).

### Response

- `birthData` (object, required): The birth moment this answer was computed from.
- `birthData.date` (string, required): Echo of the birth date.
- `birthData.time` (string, required): The birth time used, which is noon when none was sent.
- `birthData.timezone` (number, required): 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` (object, required): The Hebrew date of the birth.
- `hebrewDate.year` (number, required): Hebrew year.
- `hebrewDate.month` (string, required): 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` (number, required): Month number in the published algorithm order, Nisan first. Adar II is 13.
- `hebrewDate.day` (number, required): Day of the Hebrew month, 1 to 30.
- `hebrewDate.leapYear` (boolean, required): True in the seven years of each nineteen that carry a second Adar.
- `hebrewDate.hebrew` (string, required): The date written the way it is printed, with the day and the year in Hebrew letters. Data, identical in every language.
- `hebrewDate.afterSunset` (boolean, required): 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` (object, required): The next Hebrew birthday from targetDate (the current UTC date when omitted), the anniversary of hebrewDate. 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` (string,null, required): The Gregorian date of the next Hebrew birthday on or after targetDate, or the current UTC date when targetDate is omitted (that day when it is the birthday), or null when that Hebrew date does not exist in the year it falls in. It is the daytime civil date: the Hebrew day itself opens at nightfall the evening before.
- `hebrewBirthday.hebrewYear` (number, required): The Hebrew year of that next anniversary, always later than the birth year. Present on the null branch too, naming the year the date is missing from.
- `hebrewBirthday.note` (string): Present only when the date is null, saying why. Absent otherwise, so a caller can branch on presence.
- `angels` (array of object, required): 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` (string, required): 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` (number, required): Index of the name, 1 to 72.
- `angels[].name` (string, required): The name in Hebrew. Data, identical in every language.
- `angels[].romanization` (string, required): Latin transcription of the Hebrew, from the one mechanical letter map.
- `angels[].traditionalName` (string, required): The Latin spelling the published tables print, which is the searchable name.
- `angels[].choir` (string, required): The angelic choir the name belongs to under the published Renaissance table.
- `angels[].window` (string, required): 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` (string, required): What the tradition says this name is read for, in the requested language.
- `sephirah` (object, required): 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` (string, required): Machine identifier of the sephirah of the birth day.
- `sephirah.number` (number,null, required): Its position in the emanation, 1 to 10.
- `sephirah.english` (string, required): The English gloss of the name, in the requested language.
- `sephirah.hebrew` (string, required): The name in Hebrew. Data, identical in every language.
- `sephirah.romanization` (string, required): Latin transcription of the Hebrew, from the mechanical letter map.
- `sephirah.meaning` (string, required): What the emanation is said to hold, in the requested language.
- `conventions` (object, required): The conventions this answer was computed under, echoed so it can be reproduced.
- `conventions.angelDating` (string, required): Which construction dated the name of the day.
- `conventions.yearStart` (string, required): Where the civil wheel opened. Reported even under solar-longitude, where it selects nothing, so a stored response records every input.
- `conventions.leapDayPolicy` (string, required): Where 29 February was read as falling.
- `conventions.afterSunset` (boolean, required): Whether the Hebrew date was advanced for nightfall.

### Example request

```bash
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"}'
```

### Example response

```json
{
  "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
  }
}
```

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

`GET https://roxyapi.com/api/v2/kabbalah/names`. MCP tool `get_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.

### Request

- `lang` (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.
- `limit` (integer): Maximum items to return per page. Range: 1-72, default 20.
- `offset` (integer): Number of items to skip for pagination. Default 0.
- `longitude` (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.

### Response

- `total` (number, required): Number of names matching the request before paging, which is 72 for the list and 1 for a longitude lookup.
- `limit` (number, required): How many rows this page carries at most.
- `offset` (number, required): How many rows were skipped before this page.
- `longitude` (number): Echo of the longitude looked up. Absent when the whole list was requested.
- `names` (array of object, required): 
- `names[].number` (number, required): 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` (string, required): 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` (string, required): 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` (string, required): 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` (string, required): The suffixed name in Hebrew. Data, identical in every language.
- `names[].romanization` (string, required): 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` (string, required): 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` (number, required): First degree of the ecliptic arc this name governs, measured from 0 Aries. Inclusive.
- `names[].arcEnd` (number, required): 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.
- `names[].sign` (string, required): 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` (number, required): Where the arc opens inside its sign, 0 to 25 in steps of five.
- `names[].choir` (string, required): 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` (string, required): Which published list prints something different on this row.
- `names[].publishedDisagreement.prints` (string, required): What that list prints, so a caller matching against it can see why.

### Example request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/names/{number}`. MCP tool `get_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.

### Request

- `number` (integer, required): Index of the name, 1 to 72.
- `lang` (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.

### Response

- `number` (number, required): 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` (string, required): 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` (string, required): 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` (string, required): The divine name suffix added to make the triplet pronounceable. Forty of the seventy two take one and thirty two take the other.
- `name` (string, required): The suffixed name in Hebrew. Data, identical in every language.
- `romanization` (string, required): 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` (string, required): 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` (number, required): First degree of the ecliptic arc this name governs, measured from 0 Aries. Inclusive.
- `arcEnd` (number, required): 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` (string, required): 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` (number, required): Where the arc opens inside its sign, 0 to 25 in steps of five.
- `choir` (string, required): 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` (string, required): Which published list prints something different on this row.
- `publishedDisagreement.prints` (string, required): What that list prints, so a caller matching against it can see why.

### Example request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/tree`. MCP tool `get_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.

### Request

- `lang` (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.
- `treeVariant` (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.
- `sephirotSystem` (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.
- `letterAttribution` (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.

### Response

- `sephirot` (array of object, required): The ten emanations in order, with Daat last.
- `sephirot[].id` (string, required): 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` (number,null, required): 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` (string, required): The name in Hebrew, with vowel points. Data, identical in every language.
- `sephirot[].romanization` (string, required): 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` (string, required): The English gloss of the name, in the requested language.
- `sephirot[].pillar` (string, required): Which of the three pillars the sephirah stands on: left, middle or right. Always English.
- `sephirot[].pillarName` (string, required): Display name of the pillar, in the requested language.
- `sephirot[].world` (string,null, required): 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` (string, required): 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` (string, required): What the emanation is said to hold, in the requested language.
- `paths` (array of object, required): The 22 paths, in path order.
- `paths[].path` (number, required): 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` (string, required): Machine identifier of the letter on the path. Each of the 22 appears exactly once.
- `paths[].letterGlyph` (string, required): The letter itself. Data, identical in every language.
- `paths[].from` (string, required): Machine identifier of the sephirah the path runs from.
- `paths[].to` (string, required): Machine identifier of the sephirah the path runs to.
- `paths[].trump` (object, required): 
- `paths[].trump.id` (string, required): Identifier of the tarot trump on this path. It resolves in the Tarot API on the same key.
- `paths[].trump.number` (string, required): The trump number as the deck prints it.
- `paths[].trump.name` (string, required): Display name of the trump.
- `paths[].attribution` (object, required): 
- `paths[].attribution.kind` (string, required): What the letter attribution names: element, planet or sign.
- `paths[].attribution.value` (string, required): The element, planet or sign under the requested reading. Always English.
- `worlds` (array of object, required): The four worlds, with both published mappings of the sephirot onto them.
- `worlds[].id` (string, required): Machine identifier of the world, an ASCII romanization.
- `worlds[].hebrew` (string, required): The name in Hebrew. Data, identical in every language.
- `worlds[].romanization` (string, required): Latin transcription of the Hebrew, from the mechanical letter map.
- `worlds[].english` (string, required): The English gloss, in the requested language.
- `worlds[].sephirot` (array of string, required): Which sephirot fall in this world under the Hermetic mapping, the one the world field on each sephirah uses.
- `worlds[].sephirotAlternate` (array of string, required): 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` (array of string, required): The order the emanation descends, top to bottom. Ten identifiers, no repeats.
- `conventions` (object, required): The conventions this answer was computed under, echoed so it can be reproduced.
- `conventions.treeVariant` (string, required): Which arrangement of the paths produced this answer.
- `conventions.sephirotSystem` (string, required): Which reading assigned the spheres.
- `conventions.letterAttribution` (string, required): Which reading assigned the element, planet or sign on each path.

### Example request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/sephirot/{id}`. MCP tool `get_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.

### Request

- `id` (string enum, required): Sephirah identifier, one of keter, chokhmah, binah, chesed, gevurah, tiferet, netzach, hod, yesod, malkuth, daat. Matching folds case and punctuation.
- `lang` (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.
- `sephirotSystem` (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.
- `letterAttribution` (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.

### Response

- `id` (string, required): 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` (number,null, required): 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` (string, required): The name in Hebrew, with vowel points. Data, identical in every language.
- `romanization` (string, required): 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` (string, required): The English gloss of the name, in the requested language.
- `pillar` (string, required): Which of the three pillars the sephirah stands on: left, middle or right. Always English.
- `pillarName` (string, required): Display name of the pillar, in the requested language.
- `world` (string,null, required): 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` (string, required): 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` (string, required): What the emanation is said to hold, in the requested language.
- `paths` (array of object, required): 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` (number, required): 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` (string, required): Machine identifier of the letter on the path. Each of the 22 appears exactly once.
- `paths[].letterGlyph` (string, required): The letter itself. Data, identical in every language.
- `paths[].from` (string, required): Machine identifier of the sephirah the path runs from.
- `paths[].to` (string, required): Machine identifier of the sephirah the path runs to.
- `paths[].trump` (object, required): 
- `paths[].trump.id` (string, required): Identifier of the tarot trump on this path. It resolves in the Tarot API on the same key.
- `paths[].trump.number` (string, required): The trump number as the deck prints it.
- `paths[].trump.name` (string, required): Display name of the trump.
- `paths[].attribution` (object, required): 
- `paths[].attribution.kind` (string, required): What the letter attribution names: element, planet or sign.
- `paths[].attribution.value` (string, required): The element, planet or sign under the requested reading. Always English.
- `conventions` (object, required): The conventions this answer was computed under.
- `conventions.sephirotSystem` (string, required): Which reading assigned the sphere.
- `conventions.letterAttribution` (string, required): Which reading assigned the element, planet or sign on each path.

### Example request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/letters`. MCP tool `get_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.

### Request

- `lang` (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.
- `letterAttribution` (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.

### Response

- `total` (number, required): Number of letters returned, which is always 22.
- `letterAttribution` (string, required): Echo of the reading the attributions were taken from.
- `classCounts` (object, required): Three, seven and twelve. Every recension agrees on the split even where it disagrees on what goes where.
- `classCounts.mother` (number, required): Mother letters, which take an element.
- `classCounts.double` (number, required): Double letters, which take a planet.
- `classCounts.simple` (number, required): Simple letters, which take a sign of the zodiac.
- `letters` (array of object, required): 
- `letters[].id` (string, required): Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
- `letters[].letter` (string, required): The base glyph. Data, identical in every language.
- `letters[].final` (string,null, required): 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` (string, required): 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` (string, required): Display name of the letter, in the requested language.
- `letters[].meaning` (string, required): 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` (number, required): Position in the alphabet, 1 to 22. A property of the letter, not a cipher reading.
- `letters[].value` (number, required): Value under the standard reading. The 22 letters cover 1 to 9, 10 to 90 and 100 to 400.
- `letters[].finalValue` (number,null, required): Value in final position under the finals-500-900 reading of mispar gadol, or null where the letter has no final form.
- `letters[].letterClass` (string, required): 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` (string, required): What the class means, in the requested language.
- `letters[].attribution` (object, required): 
- `letters[].attribution.kind` (string, required): What the attribution names: element, planet or sign. Always English.
- `letters[].attribution.value` (string, required): The element, planet or sign under the requested reading. Always English, so it stays safe to compare against in code.
- `letters[].trump` (object, required): 
- `letters[].trump.id` (string, required): 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` (string, required): The trump number as the deck prints it, in Roman numerals.
- `letters[].trump.name` (string, required): Display name of the trump.
- `letters[].path` (number,null, required): 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 request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/letters/{id}`. MCP tool `get_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.

### Request

- `id` (string enum, required): 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` (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.
- `letterAttribution` (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.

### Response

- `id` (string, required): Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
- `letter` (string, required): The base glyph. Data, identical in every language.
- `final` (string,null, required): 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` (string, required): Latin transcription of the glyph, from the one mechanical letter map this API uses in both directions. A label, never a pronunciation claim.
- `name` (string, required): Display name of the letter, in the requested language.
- `meaning` (string, required): 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` (number, required): Position in the alphabet, 1 to 22. A property of the letter, not a cipher reading.
- `value` (number, required): Value under the standard reading. The 22 letters cover 1 to 9, 10 to 90 and 100 to 400.
- `finalValue` (number,null, required): Value in final position under the finals-500-900 reading of mispar gadol, or null where the letter has no final form.
- `letterClass` (string, required): 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` (string, required): What the class means, in the requested language.
- `attribution` (object, required): 
- `attribution.kind` (string, required): What the attribution names: element, planet or sign. Always English.
- `attribution.value` (string, required): The element, planet or sign under the requested reading. Always English, so it stays safe to compare against in code.
- `trump` (object, required): 
- `trump.id` (string, required): 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` (string, required): The trump number as the deck prints it, in Roman numerals.
- `trump.name` (string, required): Display name of the trump.
- `path` (number,null, required): 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 request

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

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/compatibility`. MCP tool `post_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.

### Request

- `lang` (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.
- `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.

### Response

- `first` (object, required): 
- `first.input` (string, required): The name as sent, in whichever script it was sent in.
- `first.hebrew` (string, required): The Hebrew spelling this side was scored from.
- `first.romanization` (string, required): Latin transcription of that spelling, from the one mechanical letter map.
- `first.rule` (string, required): Why this spelling was chosen over the other parses.
- `first.standard` (number, required): Value under the standard reading, which is the relation the tradition works with.
- `first.reduced` (number, required): The standard value reduced by repeated digit sum, stopping at ten.
- `first.sephirah` (string, required): Machine identifier of the sephirah the reduced value points at.
- `first.sephirahEnglish` (string, required): The English gloss of that sephirah, in the requested language.
- `second` (object, required): 
- `second.input` (string, required): The name as sent, in whichever script it was sent in.
- `second.hebrew` (string, required): The Hebrew spelling this side was scored from.
- `second.romanization` (string, required): Latin transcription of that spelling, from the one mechanical letter map.
- `second.rule` (string, required): Why this spelling was chosen over the other parses.
- `second.standard` (number, required): Value under the standard reading, which is the relation the tradition works with.
- `second.reduced` (number, required): The standard value reduced by repeated digit sum, stopping at ten.
- `second.sephirah` (string, required): Machine identifier of the sephirah the reduced value points at.
- `second.sephirahEnglish` (string, required): The English gloss of that sephirah, in the requested language.
- `sharedValues` (array of object, required): 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` (string, required): Machine identifier of the cipher the two names agree on.
- `sharedValues[].name` (string, required): Display name of that cipher.
- `sharedValues[].value` (number, required): The value both names give under it.
- `score` (number, required): 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` (string, required): Which band the composite falls in: high, moderate or low. Derived from the score, always English.
- `components` (array of object, required): Every component of the composite with its own maximum, so a caller who disagrees with the weighting can recompute rather than argue.
- `components[].id` (string, required): Machine identifier of the component.
- `components[].points` (number, required): What this component contributed.
- `components[].maximum` (number, required): The most it can contribute. The four maxima sum to 100, so the weighting is visible rather than implied.
- `components[].matched` (boolean, required): Whether the component found anything at all.
- `reading` (string, required): The composed reading, in the requested language. It states that the score is ours.
- `conventions` (object, required): 
- `conventions.transliteration` (string): The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
- `conventions.misparGadol` (string, required): Which of the two published methods the name mispar gadol was read as.

### Example request

```bash
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":"דוד"}'
```

### Example response

```json
{
  "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 https://roxyapi.com/api/v2/kabbalah/daily`. MCP tool `get_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.

### Request

- `lang` (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.
- `date` (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` (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` (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.

### Response

- `date` (string, required): The date this answer is for. Echoes the request or the resolved date.
- `inOmer` (boolean, required): 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` (string, required): Machine identifier of the sephirah, always English so it stays safe to compare against in code.
- `weekSephirah.hebrew` (string, required): The name in Hebrew, unpointed. Data, identical in every language.
- `weekSephirah.romanization` (string, required): Latin transcription of the Hebrew, from the one mechanical letter map.
- `weekSephirah.english` (string, required): 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` (string, required): Machine identifier of the sephirah, always English so it stays safe to compare against in code.
- `daySephirah.hebrew` (string, required): The name in Hebrew, unpointed. Data, identical in every language.
- `daySephirah.romanization` (string, required): Latin transcription of the Hebrew, from the one mechanical letter map.
- `daySephirah.english` (string, required): 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` (string, required): 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 request

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

### Example response

```json
{
  "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"
}
```
