Yogini Dasha vs Vimshottari Dasha: When Apps Use Each

Yogini dasha splits 36 years into eight periods, and it starts from the same Moon as Vimshottari dasha. A dasha is a planetary period: a stretch of life linked to one planet. Vimshottari is the longer system, with nine periods over 120 years.

Here is how Yogini works. Each period is named for a yogini, a goddess figure, and linked to a planet. They run in a fixed order. Mangala lasts 1 year, and each one after it lasts a year longer, up to 8. To find the first one, number the Moon's nakshatra, or birth star, starting from Ashwini. Add 3 to that number, then divide by 8. The remainder names the first yogini, and a remainder of 0 means the eighth, Sankata. The part used before birth is worked out exactly as in Vimshottari.

John Doe was born on Aug 15, 1990, at 10:30 AM in New York. His Moon is in Mrigashira, the 5th nakshatra. Then 5 + 3 = 8, which leaves 0, so he starts in Sankata, linked to Rahu. He had 7.255 of its 8 years left at birth.

So which one should your app show? Make Vimshottari the main timeline and add Yogini as a second, shorter track beside it. Label each track, and never merge the two. Below are John's real timelines from our API, compared day by day.

The eight yoginis and their years

The years run from 1 to 8, so they add up to 36, as rule YD-01 of our rulebook states. After Sankata, the cycle starts again with Mangala.

Rahu is not a physical planet. It is one of the two points where the Moon's path crosses the Sun's path. Ketu, the other point, has no yogini. So Yogini uses eight planets, while Vimshottari uses all nine. If your code maps periods to planets, keep a separate list for each system.

Step by step: John's first yogini

Find the start. The API puts John's Moon in nakshatra 5, Mrigashira. Rule YD-02 adds 3 and takes the remainder after dividing by 8. That is 0, so the first yogini is Sankata. You can check any birth star with our free nakshatra finder.

Measure the part used. The Moon had crossed 9.31% of Mrigashira. The API returns this as nakshatra_fraction_elapsed, with the value 0.09312644. So 9.31% of Sankata's 8 years passed before birth. That leaves 8 × (1 − 0.0931) = 7.255 years, which the API returns as balance_at_birth_years: 7.254988.

Share the same fraction. Vimshottari takes the very same 9.31% for John. Rule YD-03 makes both systems use one fraction and one 365.25-day year. In Vimshottari, the 9.31% comes off Mars's 7 years and leaves 6.348. Our post on how Vimshottari dasha is calculated walks through that side.

List the full period. Like Vimshottari, the API lists the first period at its full length. John's Sankata runs from Nov 16, 1989, to Nov 16, 1997. It is marked partial_at_birth, because it began before he was born.

John's two timelines, side by side

Here are John's Yogini main periods from birth to 2033:

Over the same years, Vimshottari has just four main periods, called mahadashas. Mars runs to Dec 20, 1996, then Rahu to Dec 20, 2014. Jupiter follows to Dec 20, 2030, and Saturn runs to Dec 20, 2049.

Each main period splits into sub-periods, called antardashas. In Yogini, each one lasts the main period's years × the sub-period's years ÷ 36. The API starts them with the main period's own yogini. On Oct 31, 2026, the day this post went up, John is here:

His Yogini sub-period lasts 8 × 8 ÷ 36 = 1.778 years, or 649 days. It is the longest sub-period the system has.

Where the two systems agree

We checked every day from John's birth to Nov 16, 2090, where the Yogini answer ends. That is 36,618 days.

The main periods rarely match. Both systems named the same planet on 730 days, or 2.0% of the time. That happened in two stretches. Rahu ran in both from Dec 20, 1996, to Nov 15, 1997, for 331 days. Saturn ran in both from Nov 16, 2048, to Dec 19, 2049, for 399 days.

The sub-periods match more often. The two sub-periods named the same planet on 5,034 days, or 13.7% of the time.

The starting point always matches. Both systems read one Moon, take one fraction and count one 365.25-day year. So a change to the Moon moves both timelines. Our API uses the Lahiri ayanamsa, the gap between the Western and Vedic zodiacs, unless you ask for another. With the Raman ayanamsa, John's first Yogini period ends 316.96 days earlier. His first Vimshottari period ends 277.34 days earlier. Both still start in Mrigashira, with Sankata and Mars.

Where they differ

The API returns two Yogini levels only. Rule YD-04 explains why: a third level would last only days.

Yogini repeats. John lives Sankata from before birth to age 7, then again from age 35 to 43. A third Sankata starts on Nov 16, 2061. In Vimshottari, he meets each planet's main period at most once by age 80.

Birth time moves them by different amounts. We sent John's birth to the API one minute earlier and one minute later. His first Yogini period moved 2.169 days per minute. His first Vimshottari period moved 1.898 days. The ratio is 8 to 7, the years of Sankata against the years of Mars. One hour moved his Yogini dates about 130 days.

The edge of a nakshatra changes only the first name. Born at 8:24 AM, John's Moon would still be in Rohini, the 4th nakshatra. His Yogini would open with Siddha (Venus) for about 1.2 days, and his Vimshottari with the Moon period. One minute later, both open as they do now. Between those two birth times, the end of his first Sankata moves only 2 days.

Both timelines come back from the same birth details, one call each, and every answer names its system in the system field. See what the dasha API returns for both systems, with every level and date.

When an app should show which

Rule YD-05 says the API reports the two systems side by side. Neither overrules the other, and they are never averaged. Here is how we would turn that into screens.

Make Vimshottari the main timeline. It covers the full 120-year cycle and goes down five levels. A long main period works well as the backbone of a life timeline. John's Jupiter period alone runs 16 years.

Add Yogini as a "this year" track. Its main periods run from 1 year up to 8, and its sub-periods can be as short as 10 days. So the running period changes more often. John had 17 Yogini main periods begin by age 80, against 5 in Vimshottari.

Use the repeat as a feature. A Yogini period comes back every 36 years. Your app can show users when their current yogini last ran. For John, that is "Sankata, again, after the one that ran from birth to age 7."

Draw two rows on one time axis. Put each system in its own row, with its own colors and labels. Do not combine them into one score or one current period. On Oct 31, 2026, John has Rahu in one row and Jupiter in the other.

Label every date. A date like Nov 16, 2025, means nothing without the system behind it. Show "Yogini" or "Vimshottari" next to each one.

Add text from the reading routes. The dasha routes return dates only. POST /v1/reading/section/{section_id} has a dasha section and a yogini section, so each row can carry its own reading.

Get both timelines from the API

Send the same birth details to POST /v1/dasha/yogini and POST /v1/dasha/vimshottari. Here is the request for John Doe, born Aug 15, 1990, at 10:30 AM in New York:

{
  "year": 1990,
  "month": 8,
  "day": 15,
  "hour": 10,
  "minute": 30,
  "latitude": 40.7128,
  "longitude": -74.006,
  "timezone": "America/New_York"
}

And here is the top of the Yogini answer, with the sub-periods and later periods left out:

{
  "system": "yogini",
  "total_years": 36,
  "year_length_days": 365.25,
  "moon_nakshatra_index": 5,
  "nakshatra_fraction_elapsed": 0.09312644,
  "starting_yogini": "Sankata",
  "balance_at_birth_years": 7.254988,
  "levels": 2,
  "periods": [
    {
      "yogini": "Sankata",
      "lord": "Rahu",
      "years": 8,
      "start": "1989-11-16T07:43:43.807937",
      "end": "1997-11-16T07:43:43.807937",
      "partial_at_birth": true,
      "balance_years": 7.254988
    }
  ]
}

Each Yogini period has a yogini name and a lord, its planet. A Vimshottari period has a lord only. This short JavaScript finds what runs on a date in either answer:

// Find the period that is running on a date.
function runningPeriod(periods, date) {
  return periods.find((period) => new Date(period.start) <= date && date < new Date(period.end));
}

// Main period and sub-period for one system.
function runningChain(answer, date) {
  const main = runningPeriod(answer.periods, date);
  const sub = runningPeriod(main.periods, date);
  return { system: answer.system, main: main.lord, sub: sub.lord };
}

For John on Oct 31, 2026, it returns Rahu and Rahu for yogini, and Jupiter and Moon for vimshottari. Send levels: 2 with the Vimshottari request so both answers have sub-periods.

Every field in both answers is listed in the dasha section of the API reference. The Yogini dasha glossary entry has the rules in short form.

Yogini and Vimshottari read the same Moon and start from the same point. After that, one runs in periods of 6 to 20 years and the other in periods of 1 to 8. Show both, each with its own label, and let the user read them side by side.