How do bindus help with transit timing?

When a planet transits a sign carrying many bindus in its own BAV, its results tend to be more supportive; a sign with few bindus tends to be weaker for that planet. Reading the bindu count of the transited sign, and optionally the kakshya the planet occupies, gives a quantitative layer on top of the qualitative transit reading.

The Ashtakavarga bindu system via API

Q: How is the Sarvashtakavarga total computed?

The Sarvashtakavarga (SAV) is the sum of the seven planetary BAV charts, sign by sign. Each sign ends up with a value typically between roughly 19 and 39, and the twelve values add to 337 in the standard scheme that excludes the Ascendant's own BAV from the SAV total. The API returns both the per-planet BAV grids and the consolidated SAV so you do not have to sum them client-side.

Q: Can I get Ashtakavarga for Western or KP charts?

Ashtakavarga is a sidereal Vedic technique, so the bindu engine runs on the Vedic (sidereal) chart. The same API also exposes Western (tropical) and KP computations on separate endpoints, but bindus are returned only for the Vedic system, consistent with how the technique is defined in classical Jyotish texts.

Q: Do you support trikona and ekadhipatya reduction?

Yes. The response includes the raw BAV and SAV grids and, where requested, the values after trikona sodhana (trinal reduction) and ekadhipatya sodhana (rectification for two signs owned by one planet), which are the two reductions Parashara prescribes before reading Shodya Pinda strength.

The Ashtakavarga bindu system is a scoring layer in Vedic astrology that assigns each of the twelve signs a number of benefic points (bindus) for every planet, giving a quantitative measure of strength used mainly for transit timing. Through the Vedika API you can compute the full set in one call: the seven per-planet Bhinnashtakavarga grids, the consolidated Sarvashtakavarga total, and the classical reductions. This article walks through the request shapes, the response model, and how to read the numbers the way the texts intend.

What Ashtakavarga actually computes

Ashtakavarga (literally "the eight-fold division") is described at length in the Brihat Parashara Hora Shastra. The idea is that each planet's results in a given sign are conditioned by where the other planets sit relative to it. For every planet, classical contribution tables list which houses, counted from each of the eight reference points (the seven planets plus the Ascendant), are benefic. Tally those benefic positions across all twelve signs and you get that planet's Bhinnashtakavarga (BAV) chart, a row of twelve numbers from 0 to 8.

Sum the seven planetary BAV charts sign by sign and you get the Sarvashtakavarga (SAV), a single chart of twelve totals that summarises overall sign strength. The technique is computational by nature, which is precisely why it suits an API: the tables are fixed, the arithmetic is deterministic, and the value to a developer is in not re-implementing the contribution matrices by hand.

The three things you get back

BAV (Bhinnashtakavarga): one grid per planet, 0–8 bindus across twelve signs.
SAV (Sarvashtakavarga): the seven BAV grids summed, twelve totals that add to 337 in the standard Ascendant-excluded scheme.
Reductions: trikona sodhana and ekadhipatya sodhana, the two corrections Parashara prescribes before deriving Shodya Pinda strength figures.

The endpoint and request shape

Bindus are part of the Vedic (sidereal) computation surface. You can ask for them through the natural-language query endpoint when you want a narrated reading, or through the V2 computation endpoints when you want the raw grids as structured JSON. For integration work you almost always want the latter.

All requests authenticate with an API key header. The base URL is https://api.vedika.io. Birth input on the V2 surface is flat: datetime (ISO 8601 with offset), latitude, longitude, and an IANA timezone.

curl -X POST https://api.vedika.io/v2/astrology/ashtakavarga \
  -H "x-api-key: vk_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "datetime": "1990-08-15T14:30:00+05:30",
    "latitude": 18.5204,
    "longitude": 73.8567,
    "timezone": "Asia/Kolkata",
    "reductions": ["trikona", "ekadhipatya"]
  }'

If you would rather receive an interpreted answer in plain language, the AI query endpoint takes a question plus a nested birthDetails object:

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": "Which signs are strongest in my Sarvashtakavarga and what does that mean for upcoming Saturn transit?",
    "birthDetails": {
      "datetime": "1990-08-15T14:30:00+05:30",
      "latitude": 18.5204,
      "longitude": 73.8567,
      "timezone": "Asia/Kolkata"
    },
    "speed": "fast"
  }'

Reading the structured response

The V2 response returns the per-planet grids keyed by planet, the SAV row, and the reduced figures when requested. Signs are ordered from Aries through Pisces (sign index 1–12) so you can align them with a house or rasi map directly.

Field	Shape	Meaning
`bav`	object keyed by planet → 12 ints (0–8)	Each planet's Bhinnashtakavarga grid
`sav`	array of 12 ints	Sarvashtakavarga totals per sign
`savTotal`	int	Sum of `sav`; 337 in the standard scheme
`reductions.trikona`	object keyed by planet	BAV after trinal reduction
`reductions.ekadhipatya`	object keyed by planet	BAV after two-sign-lordship rectification

A worked client example

Here is a small JavaScript client that pulls the Ashtakavarga, finds the strongest and weakest signs in the SAV, and flags any sign carrying fewer than 25 SAV bindus, a common threshold practitioners treat as a soft floor for the sign hosting an important house.

const BASE = "https://api.vedika.io";
const SIGNS = ["Aries","Taurus","Gemini","Cancer","Leo","Virgo",
  "Libra","Scorpio","Sagittarius","Capricorn","Aquarius","Pisces"];

async function getAshtakavarga(birth) {
  const res = await fetch(`${BASE}/v2/astrology/ashtakavarga`, {
    method: "POST",
    headers: {
      "x-api-key": process.env.VEDIKA_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ ...birth, reductions: ["trikona", "ekadhipatya"] }),
  });
  if (!res.ok) throw new Error(`Ashtakavarga request failed: ${res.status}`);
  return res.json();
}

function summariseSav(sav) {
  const ranked = sav
    .map((bindus, i) => ({ sign: SIGNS[i], bindus }))
    .sort((a, b) => b.bindus - a.bindus);
  return {
    strongest: ranked[0],
    weakest: ranked[ranked.length - 1],
    belowFloor: ranked.filter((r) => r.bindus < 25),
  };
}

const data = await getAshtakavarga({
  datetime: "1990-08-15T14:30:00+05:30",
  latitude: 18.5204,
  longitude: 73.8567,
  timezone: "Asia/Kolkata",
});
console.log(summariseSav(data.sav));

The same flow in Python, using any standard HTTP client:

import os, requests

BASE = "https://api.vedika.io"
SIGNS = ["Aries","Taurus","Gemini","Cancer","Leo","Virgo",
         "Libra","Scorpio","Sagittarius","Capricorn","Aquarius","Pisces"]

def get_ashtakavarga(birth):
    r = requests.post(
        f"{BASE}/v2/astrology/ashtakavarga",
        headers={"x-api-key": os.environ["VEDIKA_API_KEY"]},
        json={**birth, "reductions": ["trikona", "ekadhipatya"]},
        timeout=20,
    )
    r.raise_for_status()
    return r.json()

data = get_ashtakavarga({
    "datetime": "1990-08-15T14:30:00+05:30",
    "latitude": 18.5204,
    "longitude": 73.8567,
    "timezone": "Asia/Kolkata",
})

ranked = sorted(
    ({"sign": SIGNS[i], "bindus": b} for i, b in enumerate(data["sav"])),
    key=lambda x: x["bindus"], reverse=True,
)
print("strongest:", ranked[0], "weakest:", ranked[-1])

From bindus to transit timing

The practical payoff of Ashtakavarga is transit (gochara) evaluation. When a planet transits a sign that holds many bindus in its own BAV, the texts treat its results there as more supportive; a sign with few bindus tends to dilute them. A typical workflow is: fetch the natal BAV once, then for each transit check the bindu count of the sign the transiting planet currently occupies.

Kakshya refinement

Each sign in a planet's BAV is further divided into eight kakshyas of 3°45' each, ruled in a fixed sequence by Saturn, Jupiter, Mars, the Sun, Venus, Mercury, the Moon, and the Ascendant. Whether the kakshya the transiting planet sits in is one that contributed a bindu sharpens the reading from a per-sign score to a per-segment one. If you want the kakshya overlay, request it explicitly and pair it with the planet's current sidereal longitude from the chart endpoint.

Reductions before strength figures

Before deriving Shodya Pinda (the consolidated strength figures), Parashara prescribes two reductions: trikona sodhana, which rectifies bindus among the three signs of a trine, and ekadhipatya sodhana, which adjusts for the two signs ruled by a single planet. The API performs both so you do not have to reproduce the conditional rules, which are easy to get subtly wrong. Reductions are interpretive aids defined in the classical texts; if you only need raw transit floors, the unreduced SAV is enough.

Why compute this server-side

You could implement the contribution matrices yourself; they are public and finite. The reasons to call an API instead come down to correctness and breadth. The bindu tables interact with the sidereal chart, so every count is downstream of the underlying planetary positions. Vedika computes those with the XALEN Ephemeris, its own open-source astronomical engine (Apache-2.0, published to crates.io, PyPI, and npm as a WASM build), which carries roughly 2,200 tests and has been validated against JPL DE440 and swetest with no chart deviating beyond 0.1 degree across a five-million-chart test. That is astronomical precision in the positions the bindu rules consume; the bindu rules themselves are the deterministic classical tables on top.

Because the same key spans more than 600 operations across 25 domains, you can fetch the Ashtakavarga alongside the divisional charts, dashas, and yogas the reading actually depends on, without stitching together multiple vendors. Three systems live in one API: Vedic (sidereal), Western (tropical), and KP, plus Jaimini, Tajaka, Lal Kitab, and numerology, with output available in 30 languages.

Citations and what we do not invent

Every bindu rule in the engine traces to the contribution tables in the Brihat Parashara Hora Shastra, with the gochara reading conventions and reduction procedures drawn from the same classical Jyotish corpus that practitioners train on, including Phaladeepika for transit interpretation. The API does not fabricate verse numbers or attach invented strength percentages to a chart; it returns the computed bindus and the classically defined reductions, and any narrated interpretation is grounded in those sources rather than paraphrased generalities.

Key facts

A bindu is a benefic point (0–8 per sign) a planet contributes in its Bhinnashtakavarga.
The Sarvashtakavarga sums the seven planetary BAV charts; the twelve totals add to 337 in the standard Ascendant-excluded scheme.
Bindus are a Vedic (sidereal) technique; the engine returns them for the Vedic system.
Trikona sodhana and ekadhipatya sodhana reductions are available on request, as defined by Parashara.
Each BAV sign splits into eight kakshyas of 3°45' for finer transit timing.
Positions feeding the bindu tables are computed with the XALEN Ephemeris, validated against JPL DE440 and swetest within 0.1°.
Endpoints: POST /v2/astrology/ashtakavarga (structured) and POST /api/v1/astrology/query (narrated). Auth: x-api-key: vk_live_*.

Getting started

You can try the request shapes against the free sandbox with no key, then move to a live key when you are ready. Per-query usage runs from a few cents, and plans start at the Starter tier; see pricing for the full breakdown. Full request and response schemas live in the documentation, and if you are working with divisional charts alongside bindus, the vargas via API deep dive pairs well with this one.

FAQ

What is a bindu in Ashtakavarga?

A bindu is a benefic point a planet contributes to a sign. In each planet's Bhinnashtakavarga, every sign receives 0 to 8 bindus from the seven planets plus the Ascendant, per the classical contribution tables. More bindus mark signs where that planet expresses more favourably.

How is the Sarvashtakavarga total computed?

It is the sum of the seven planetary BAV charts, sign by sign. Each sign lands roughly between 19 and 39, and the twelve values total 337 in the standard Ascendant-excluded scheme. The API returns both the BAV grids and the consolidated SAV.

Can I get Ashtakavarga for Western or KP charts?

Bindus run on the Vedic (sidereal) chart, consistent with the classical definition. Western and KP computations are available on their own endpoints, but bindus are returned only for the Vedic system.

Do you support trikona and ekadhipatya reduction?

Yes. The response includes the raw grids and, on request, the values after trikona sodhana and ekadhipatya sodhana, the two reductions Parashara prescribes before reading Shodya Pinda strength.