Arudha Lagna and Jaimini astrology via API

Arudha Lagna and the Jaimini system are two of the most distinctive layers of classical Indian astrology, and they are computed end-to-end inside a single Vedika API call. Send a birth moment to POST /api/v1/astrology/query and ask a Jaimini question, or hit the /v2/astrology/* computation endpoints to pull the raw Arudha padas, Chara Karakas, and Chara Dasha periods as structured JSON. No separate engine, no glue code between sidereal positions and Jaimini logic.

What Arudha Lagna and Jaimini actually are

Most astrology APIs stop at the Parashari toolkit: the natal chart, divisional charts, Vimshottari Dasha, and planetary aspects. Jaimini is a parallel, equally classical framework that reads the same chart through a different lens. It comes from the Jaimini Sutras, and it introduces concepts that have no direct Parashari equivalent.

Arudha Lagna (the perceived self)

The Arudha Lagna (AL) is the image of the Ascendant -- how a person is perceived by the world, as opposed to who they intrinsically are. It is derived by counting from the Lagna to its lord, then counting the same distance again from the lord. Every house has its own Arudha pada (A2 through A12), and the 12th-from-Lagna pada (the Upapada, A12) is the classical significator most astrologers consult for marriage and partnership themes.

Jaimini Chara Karakas (the moving significators)

Where Parashari uses fixed natural karakas (Jupiter always signifies children, Venus always signifies spouse), Jaimini assigns significators dynamically by degree. The planet at the highest degree within its sign becomes the Atmakaraka (the soul significator); the next becomes the Amatyakaraka, and so on through eight Chara Karakas. The Atmakaraka is the single most important point in a Jaimini reading.

Chara Dasha (sign-based timing)

Vimshottari Dasha is planet-based and runs on a fixed 120-year cycle keyed to the Moon's nakshatra. Chara Dasha is sign-based: each Rasi rules for a variable number of years determined by the distance from the sign to its lord. It is the timing engine native to Jaimini, and it pairs with Arudha analysis for prediction.

Why compute Jaimini through an API at all

Jaimini logic is deceptively easy to get wrong. The counting rules for Arudha have documented exceptions -- when a pada would fall on the same sign as its house or in the 7th from it, classical texts prescribe a correction (the pada is shifted to the 10th from the computed position). The Chara Karaka scheme has a long-standing debate over whether to use seven karakas or eight (the difference is whether Rahu is included), and the order of Chara Dasha depends on whether the sign is odd or even and on the direction of counting.

Implementing all of this correctly on top of raw ephemeris output is a multi-week project that most teams should not own. Vedika handles the sidereal longitudes, the degree ranking, the pada corrections, and the dasha sequencing, and exposes the result as plain JSON. The astronomical layer underneath -- planetary positions to sub-arcminute precision -- comes from the open-source XALEN Ephemeris, validated against JPL DE440 and swetest with no chart deviating beyond 0.1 degrees across a reproducible JPL DE440 benchmark. That is astronomical precision for the chart math; the astrological interpretation on top is a separate, sourced layer.

The two ways to get Jaimini data

The query endpoint is for product surfaces -- chat, reports, voice -- where you want a sentence, not a spreadsheet. The V2 computation endpoints are for when you are building your own interpretation layer and just need the numbers.

A natural-language Jaimini query

Send the question and the birth details. The birthDetails object carries an ISO datetime, latitude, longitude, and an IANA timezone string. Add "speed": "fast" to route through Vedika Swift when latency matters more than depth.

curl -X POST https://api.vedika.io/api/v1/astrology/query \
  -H "x-api-key: vk_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "question": "What does my Atmakaraka and Arudha Lagna say about my public image?",
    "birthDetails": {
      "datetime": "1990-08-15T14:30:00",
      "latitude": 18.5204,
      "longitude": 73.8567,
      "timezone": "Asia/Kolkata"
    }
  }'

The response is an interpreted reading where every astrological assertion is backed by a computed value -- the Atmakaraka is identified by degree, the Arudha Lagna sign is calculated, and the interpretation is attributable to classical Jaimini doctrine rather than improvised. Citations trace to the Jaimini Sutras and standard Parashari support texts; the engine does not invent verse numbers or fabricate authority.

Pulling raw Jaimini structures

For a build-your-own pipeline, the V2 computation surface takes flat parameters (datetime, latitude, longitude, timezone) and returns structured data you can render or feed into your own logic.

import requests

BASE = "https://api.vedika.io"
HEADERS = {"x-api-key": "vk_live_your_key_here"}

params = {
    "datetime": "1990-08-15T14:30:00",
    "latitude": 18.5204,
    "longitude": 73.8567,
    "timezone": "Asia/Kolkata",
}

# Chara Karakas (Atmakaraka, Amatyakaraka, ...) ranked by degree
karakas = requests.get(
    f"{BASE}/v2/astrology/jaimini/chara-karakas",
    headers=HEADERS, params=params,
).json()

# Arudha padas A1 (Arudha Lagna) through A12 (Upapada)
arudha = requests.get(
    f"{BASE}/v2/astrology/jaimini/arudha-padas",
    headers=HEADERS, params=params,
).json()

atmakaraka = karakas["charaKarakas"]["atmakaraka"]
print(f"Atmakaraka: {atmakaraka['planet']} at {atmakaraka['degree']}")
print(f"Arudha Lagna sign: {arudha['padas']['A1']['sign']}")

Because all three systems share one chart object, you can read the same birth through Vedic, Western, and KP lenses in one integration and overlay Jaimini on top without re-sending coordinates or re-deriving the ephemeris.

Three systems, one chart

Jaimini does not live in isolation. Vedika computes Vedic (sidereal), Western (tropical), and KP from the same birth input, alongside Jaimini, Tajaka annual charts, Lal Kitab, and numerology. A practical Jaimini workflow usually cross-checks against the Parashari chart -- the Atmakaraka's placement is read in the natal chart and the Navamsa (D9), and the Upapada is compared against the 7th house for relationship analysis. Having both frameworks return from one API removes an entire class of reconciliation bugs (different ayanamsa, different house system, mismatched timezone handling) that appear when you stitch two providers together.

Honest comparison with other providers

Several astrology APIs do real, useful work in the Parashari space. Prokerala (around $19/mo) has broad coverage of mainstream Vedic calculations and clear documentation. AstrologyAPI.com (around $29/mo) ships a large catalog of report-style endpoints. RoxyAPI (around $39/mo) is solid for Western and ephemeris data. If your product only needs standard Vimshottari and natal charts, any of these may fit your needs.

Where Vedika differs is the breadth of classical systems exposed as first-class computation, including Jaimini's Arudha and Chara Karaka schemes, plus a single integration that covers Vedic, Western, and KP together. Vedika also publishes its ephemeris engine as open source (Apache-2.0) and ships a public Model Context Protocol server so an AI assistant or LLM agent can call astrology tools directly. Pricing runs from $12/mo (Starter) to $240/mo (Enterprise), with per-query costs of roughly $0.01 to $0.05, and there is a free sandbox that needs no key so you can validate Jaimini output before committing.

Calling Jaimini from an AI assistant

If you are building an agent, you do not have to write HTTP plumbing. Vedika ships a public astrology MCP server with 36 tools, installable in any MCP-compatible client or IDE:

npx @vedika-io/mcp-server

Once connected, a function-calling model can request the Atmakaraka, Arudha Lagna, or a Chara Dasha timeline by name and receive structured results -- the same computation surface described above, exposed as agent tools rather than raw endpoints.

Key facts

• Arudha Lagna and Jaimini Chara Karakas are computed via POST /api/v1/astrology/query (natural language) or /v2/astrology/* (structured JSON).
• The Atmakaraka is the planet at the highest degree in its sign; the Arudha Lagna (A1) is the perceived-self pada, and the Upapada (A12) is the classical marriage significator.
• Chara Dasha is the sign-based timing system native to Jaimini, distinct from planet-based Vimshottari Dasha.
• Vedika exposes 700+ operations across 25 domains (704 enumerated in June 2026) and three systems -- Vedic, Western, KP -- plus Jaimini, Tajaka, Lal Kitab, and numerology in one API.
• Astronomical positions come from the open-source XALEN Ephemeris (Apache-2.0), validated against JPL DE440 and swetest with no chart deviating beyond 0.1 degrees across a reproducible JPL DE440 benchmark.
• Auth header is x-api-key: vk_live_*; base URL is https://api.vedika.io; 30 languages including 14 Indic are supported.
• A free, no-key sandbox lets you validate Jaimini output before integrating.

Where to go next

Read the endpoint reference in the docs, try a live Jaimini call in the sandbox, and check the pricing tiers to match per-query volume. For the broader picture of how the three systems coexist, see the related write-up on sidereal versus tropical zodiac handling.

FAQ

Can I get Jaimini results without writing interpretation logic?

Yes. The POST /api/v1/astrology/query endpoint returns an interpreted reading grounded in computed Jaimini facts, so you can ship a Jaimini feature without building your own analysis layer.

What is the difference between Arudha Lagna and the Ascendant?

The Ascendant is the intrinsic self; the Arudha Lagna is the perceived self -- how the world sees the person. It is derived by counting from the Lagna to its lord and the same distance again, with classical corrections applied for special cases.

Does the API include Chara Dasha timing?

Yes. Chara Dasha, the sign-based timing system from the Jaimini Sutras, is available through the V2 computation surface alongside the Arudha padas and Chara Karakas.

How accurate are the underlying planetary positions?

The positions come from the open-source XALEN Ephemeris, validated against JPL DE440 and swetest with no chart deviating beyond 0.1 degrees across a five-million-chart test. That is astronomical precision for the chart math; the astrological interpretation is a separate, source-cited layer.