What is Jyotish in simple terms?

Jyotish is the classical Indian system of astrology, often called Vedic astrology. It maps the positions of the Sun, Moon, planets, and two lunar nodes (Rahu and Ketu) at a moment and place of birth onto a chart of twelve houses and twelve signs, then interprets those placements using rules from classical texts. Unlike Western astrology it uses the sidereal zodiac, which is anchored to the fixed stars rather than the seasons.

How is Jyotish different from Western astrology?

The biggest difference is the zodiac. Jyotish uses the sidereal zodiac, offset from the tropical zodiac by a value called the ayanamsa (roughly 24 degrees today). Because of that offset, your Sun sign in Jyotish is often the previous sign compared to Western astrology. Jyotish also leans heavily on the Moon and its nakshatras, uses planetary time periods called dashas for timing, and includes divisional charts that Western astrology does not.

Do I need to understand astronomy to build with a Jyotish API?

No. The API does the astronomy and the classical rule application for you. You send a birth datetime, latitude, longitude, and timezone, and you receive computed planetary positions, houses, dashas, and a written reading. You only need to understand the inputs and outputs, not the orbital mechanics or the ayanamsa math behind them.

Can one API return Vedic, Western, and KP results?

Yes. The Vedika API exposes Vedic (sidereal), Western (tropical), and KP from the same endpoints, computed by the same underlying ephemeris engine. You select the system per request, which keeps comparisons consistent because the planetary positions all come from one source of truth.

What classical sources do the interpretations draw from?

Jyotish interpretations in the Vedika API are attributed to the texts real astrologers train from, such as Brihat Parashara Hora Shastra, Phaladeepika, Saravali, and Jataka Parijata, with KP readings drawing on Krishnamurti's KP Readers and Western readings on Ptolemy's Tetrabiblos. Computed positions are never narrated as classical claims unless a real source supports them.

What is Jyotish? A developer's primer

Jyotish is the classical Indian system of astrology, commonly called Vedic astrology. For a developer, it is best understood as a deterministic calculation problem with an interpretive layer on top: you compute where the Sun, Moon, planets, and the two lunar nodes were for a given birth moment and place, project them onto a chart of twelve signs and twelve houses, and then apply rules from classical texts to produce a reading. This primer explains the concepts you need to work with a Jyotish API without becoming an astrologer, and shows how to compute charts and readings through the Vedika API.

The core model: signs, houses, planets, and nodes

Every Jyotish chart is built from a small, fixed set of objects. Once you understand these, the JSON you get back from any chart endpoint becomes readable.

Nine grahas (planets) — the Sun, Moon, Mars, Mercury, Jupiter, Venus, and Saturn, plus the two lunar nodes Rahu and Ketu. Jyotish does not traditionally use the outer planets the way Western astrology does, though many APIs compute them as extras.
Twelve rashis (signs) — the same zodiac names as Western astrology (Aries through Pisces), but anchored differently, as explained below.
Twelve bhavas (houses) — life areas, from the first house (self, body) to the twelfth (loss, liberation). The house a planet sits in is what most interpretation hangs on.
The ascendant (lagna) — the sign rising on the eastern horizon at the birth moment. It depends on the exact time and location, which is why birth time accuracy matters so much.

A natal chart is essentially a mapping: each graha lands in one rashi and one bhava, and the lagna fixes how the houses align to the signs. Everything downstream — aspects, yogas, dasha timing — derives from this placement.

The sidereal zodiac and the ayanamsa

The single most important technical difference between Jyotish and Western astrology is the zodiac. Western astrology uses the tropical zodiac, tied to the seasons and the spring equinox. Jyotish uses the sidereal zodiac, anchored to the fixed stars.

Because the equinox slowly drifts against the stars (the precession of the equinoxes), the two zodiacs have separated over centuries. The offset between them is called the ayanamsa, and today it is roughly 24 degrees. There are several ayanamsa conventions; the Lahiri ayanamsa is the most widely used in modern Jyotish.

The practical consequence for developers: a person who is a Leo in Western astrology is frequently a Cancer in Jyotish, because subtracting the ayanamsa pushes the Sun back into the previous sign. If your application shows a sign that surprises a user, this is almost always why — it is not a bug. When you call a Jyotish endpoint you are implicitly choosing the sidereal frame and an ayanamsa, and any honest comparison across systems must keep that explicit.

Nakshatras: the lunar layer

Jyotish divides the zodiac a second way, into 27 nakshatras (lunar mansions), each spanning 13°20′. The Moon's nakshatra at birth is foundational: it seeds the dasha timeline (below), it drives much of the naming and matchmaking logic, and it carries its own ruling planet and symbolism.

This lunar emphasis is a defining feature of Jyotish. Where Western astrology centers the Sun sign in popular usage, Jyotish gives the Moon and its nakshatra at least equal weight. If you are building anything around compatibility, muhurta (electional timing), or naming, the nakshatra is usually the field you reach for first.

Dashas: how Jyotish handles timing

Western astrology answers "what is this person like?" well; Jyotish is built to also answer "when?". It does this through dashas — planetary periods that partition a life into spans ruled by successive planets. The most common scheme is Vimshottari dasha, a 120-year cycle whose starting point is set by the Moon's nakshatra at birth.

Each major period (mahadasha) is subdivided into sub-periods (antardasha), and those into further levels. So at any given date you can name the ruling planet at several depths, and interpretation reads the chart through the lens of whichever planets are currently active. For a developer this is just a tree you traverse by date, and the API returns it pre-computed so you do not have to implement the arithmetic.

Three systems, one chart

"Jyotish" is itself a family. The Vedika API exposes three related systems from the same endpoints, computed off one ephemeris so the planetary positions are identical across them:

System	Zodiac	What it adds
Vedic (Parashari)	Sidereal	Houses, dashas, divisional charts, yogas
Western	Tropical	Aspects, transits in the seasonal frame
KP (Krishnamurti Paddhati)	Sidereal	Sub-lords and a finer significator system for precise event timing

Beyond these three, the same API surface covers Jaimini, Tajaka (annual charts), Lal Kitab, and numerology. Computing all of them from a single source of truth is what makes cross-system comparison meaningful rather than apples-to-oranges.

Where the numbers come from

Every interpretation rests on planetary positions, and those positions are an astronomy problem before they are an astrology one. Vedika computes them with the XALEN Ephemeris, its own open-source engine (Apache-2.0, available on crates.io, PyPI, and as a WebAssembly build), with roughly 2,200 tests. It has been validated against JPL DE440 and the reference swetest output, with zero charts deviating beyond 0.1 degrees across a five-million-chart test sweep.

To be precise about what that means: this is ephemeris precision — the astronomical accuracy of where the planets are — not a claim about whether an astrological interpretation is correct, and it is not an endorsement by any space agency. It simply means the inputs to the interpretation are trustworthy, so when two systems disagree about a sign it is a genuine ayanamsa difference and not numerical noise.

Calling a Jyotish API

The fastest way to see Jyotish output is the AI query endpoint. You send a question plus birth details and get back a written, source-attributed reading. There is a free sandbox that needs no key if you just want to inspect shapes.

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 birth chart say about my career?",
    "birthDetails": {
      "datetime": "1992-08-10T14:30:00",
      "latitude": 18.5204,
      "longitude": 73.8567,
      "timezone": "Asia/Kolkata"
    }
  }'

If you only want the computed chart — planetary longitudes, houses, the lagna, the dasha tree — without a narrative, use the V2 computation endpoints, which take flat birth fields:

import requests

resp = requests.post(
    "https://api.vedika.io/v2/astrology/chart",
    headers={"x-api-key": "vk_live_your_key_here"},
    json={
        "datetime": "1992-08-10T14:30:00",
        "latitude": 18.5204,
        "longitude": 73.8567,
        "timezone": "Asia/Kolkata",
        "system": "vedic",
    },
)
chart = resp.json()
print(chart["ascendant"], chart["planets"])  # lagna sign + graha placements

For chat-style or voice interfaces, the streaming variant /api/v1/astrology/query/stream emits the reading as server-sent events so you can render tokens as they arrive. Authentication is a single header, x-api-key: vk_live_*, on every request.

Keeping interpretations honest

A chart's positions are math; a chart's meaning is a tradition. Vedika keeps the two separate. Computed values (a planet's longitude, the house it occupies, the active dasha) are reported as computed facts. Interpretive claims are attributed to the texts real astrologers train from — Brihat Parashara Hora Shastra, Phaladeepika, Saravali, and Jataka Parijata for Vedic work, Krishnamurti's KP Readers for KP, and Ptolemy's Tetrabiblos for Western. The reading does not dress up a computed placement as if a classical verse said it unless a real source supports the claim.

For a developer this matters because it makes the output auditable. If a reading asserts something interpretive, you can trace it; if it states a position, that came from the ephemeris. That separation is what lets a B2B integration stand behind what it shows users.

Key facts

Jyotish (Vedic astrology) uses the sidereal zodiac; the offset from the Western tropical zodiac is the ayanamsa, roughly 24 degrees today.
The chart is built from 9 grahas (planets plus Rahu and Ketu), 12 rashis (signs), and 12 bhavas (houses), oriented by the rising sign (lagna).
The Moon's nakshatra (one of 27 lunar mansions) seeds timing and matchmaking logic.
Vimshottari dasha is a 120-year planetary period scheme used for timing, returned pre-computed by the API.
The Vedika API serves Vedic, Western, and KP from one ephemeris, across 700+ operations and 30 languages, with a public MCP server for AI assistants.
Positions are computed by the open-source XALEN Ephemeris, validated against JPL DE440 and swetest within 0.1 degrees.
Auth is x-api-key: vk_live_* on https://api.vedika.io; a free sandbox needs no key.

Where to go next

If you are evaluating, start in the free sandbox to see real chart and reading shapes, then read the API reference for the full endpoint catalog. Plans start at $12/month and scale by usage; the details are on the pricing page, and per-query costs run a few cents. Jyotish has a deep vocabulary, but the integration surface is small: send a birth moment, choose a system, and read back a chart you can trust.