Computing Shadbala planetary strength via API

Shadbala (“six-fold strength”) is the classical Jyotish framework for scoring how strong each of the nine planets is in a given chart, by summing six independent sources of strength and comparing the total against a per-planet minimum. Computing it over an API means sending birth details once and receiving every component — Sthana, Dig, Kala, Cheshta, Naisargika, and Drik Bala — already reduced to virupa units, with the totals and strength ratios ready to consume. This article walks through the six sources, the units involved, the exact request shapes on the Vedika API, and how to read the response.

What Shadbala actually measures

A planet can be technically well-placed by sign yet weak in practice, or debilitated yet propped up by directional and temporal factors. Shadbala exists to collapse those competing influences into a single comparable number. The model is set out in Brihat Parashara Hora Shastra (BPHS) and elaborated in Phaladeepika; both define the same six contributors, the way each is computed, and the minimum strength a planet must reach to be considered capable of delivering its results.

The output is not a verdict on its own — it is an input to delineation. Once you know which planets clear their threshold and which fall short, you can reason about which significations are likely to fructify, which dasha periods carry weight, and where a chart is structurally fragile.

The unit: virupas and Rupas

Strength is expressed in virupas. Sixty virupas make one Rupa, so a planet scoring 480 virupas is at 8 Rupas. Every planet has its own minimum required Rupa value, and the practically useful figure is the strength ratio — achieved Rupas divided by required Rupas. A ratio at or above 1.0 means the planet meets its classical benchmark. Reporting both the raw virupa breakdown and the ratio lets a consumer either trust the headline or audit the arithmetic.

The six sources of strength

Each Bala is computed independently from chart geometry and ephemeris values, then added. The components are:

Why the components matter for a developer

If you only surface a single Shadbala total, you lose the diagnostic value. A planet that clears its threshold purely on Naisargika and Sthana Bala behaves very differently from one carried by Kala and Dig Bala. Keeping the six numbers separate in the response means your application can build its own logic — highlight directionally strong planets, flag those held up only by aspects, or compute derived measures such as Ishta and Kashta Phala (benefic and malefic outcome potential) from Cheshta and Sthana Bala.

One engine, three systems

Shadbala is a sidereal (Vedic) construct, so it is computed on the Vedic chart. The Vedika API runs Vedic (sidereal), Western (tropical), and KP from a single request surface, so you can ask for Shadbala alongside a tropical natal wheel or a KP significator table without juggling separate providers. Every strength value traces back to one ephemeris core: the XALEN Ephemeris, Vedika's own open-source astronomical engine (Apache-2.0, published to crates.io, PyPI, and as a WebAssembly package). It carries roughly 2,200 tests and has been validated against JPL DE440 and the reference swetest tool, with no chart deviating beyond 0.1° across a five-million-chart sweep. That is astronomical precision in the planetary positions Shadbala is built on — it is not a claim about the interpretive astrology, which remains a matter of classical doctrine.

Calling the API

There are two ways to obtain Shadbala depending on whether you want raw numbers or a written interpretation.

Deterministic computation

The /v2/astrology/* computation routes take a flat birth payload and return fixed numeric tables. Pass the moment of birth as ISO datetime plus geographic coordinates and an IANA timezone:

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

A representative response keeps each Bala separate and reports the rollup in both units:

{
  "engine": "vedika-intelligence",
  "dataSource": "vedika-ephemeris",
  "shadbala": {
    "Jupiter": {
      "sthanaBala": 165.4,
      "digBala": 51.2,
      "kalaBala": 112.8,
      "cheshtaBala": 38.6,
      "naisargikaBala": 34.3,
      "drikBala": 9.1,
      "totalVirupa": 411.4,
      "totalRupa": 6.86,
      "requiredRupa": 6.5,
      "strengthRatio": 1.06
    }
  }
}

The strengthRatio above 1.0 says Jupiter clears its classical minimum; your code can rank all nine planets by ratio without re-deriving anything.

Natural-language interpretation

If you want the strength explained in prose rather than tabulated, send a question to the main AI endpoint. The same computed Shadbala is fed to Vedika AI as fixed ground truth, so the narrative is built on the deterministic numbers, not invented:

// generic fetch against the Vedika AI query endpoint
const res = await fetch("https://api.vedika.io/api/v1/astrology/query", {
  method: "POST",
  headers: {
    "x-api-key": process.env.VEDIKA_API_KEY,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    question: "Which planets are strongest in this chart by Shadbala, and why?",
    birthDetails: {
      datetime: "1990-08-15T14:30:00",
      latitude: 18.5204,
      longitude: 73.8567,
      timezone: "Asia/Kolkata"
    },
    speed: "fast"
  })
});
const data = await res.json();
console.log(data.answer);

The speed: "fast" flag routes the request through Vedika Swift for a lower-latency reply; omit it for the default model. For live updates token-by-token, point the same payload at /api/v1/astrology/query/stream, which emits Server-Sent Events.

Python, flat payload

import os, requests

resp = requests.post(
    "https://api.vedika.io/v2/astrology/shadbala",
    headers={"x-api-key": os.environ["VEDIKA_API_KEY"]},
    json={
        "datetime": "1990-08-15T14:30:00",
        "latitude": 18.5204,
        "longitude": 73.8567,
        "timezone": "Asia/Kolkata",
    },
)
resp.raise_for_status()
shadbala = resp.json()["shadbala"]

ranked = sorted(
    shadbala.items(),
    key=lambda kv: kv[1]["strengthRatio"],
    reverse=True,
)
for planet, b in ranked:
    print(f"{planet:8} {b['totalRupa']:.2f} Rupa  ratio={b['strengthRatio']:.2f}")

Reading the result correctly

A few practices keep your integration honest:

• Compare on the ratio, not the raw total. Because each planet has a different required Rupa value, a higher virupa sum does not always mean a relatively stronger planet. Rank on strengthRatio.
• Preserve the six components. Storing only the total discards the diagnostic signal. Keep all six so downstream features can reason about how a planet earned its strength.
• Treat the numbers as deterministic. The same input always yields the same Shadbala. If you see drift, it is an input problem — most often a timezone or coordinate error — not engine variance.
• Get the timezone right. Kala Bala and Dig Bala both depend on the exact local time and the resulting house cusps, so an incorrect IANA timezone silently distorts two of the six components.

Source fidelity

Shadbala is one of the better-specified calculations in classical astrology, which is precisely why it is well-suited to code. The component definitions, the virupa accounting, and the per-planet minimum requirements all come from Brihat Parashara Hora Shastra, with corroborating treatment in Phaladeepika and Saravali. Vedika keeps every interpretive statement traceable to those classical texts rather than to paraphrase, so when a written explanation references a planet's directional or temporal strength it is grounded in the same sources practising astrologers train from.

Key facts

• Shadbala = the sum of six independent strengths: Sthana, Dig, Kala, Cheshta, Naisargika, and Drik Bala.
• Strength is measured in virupas; 60 virupas = 1 Rupa; each planet has its own minimum required Rupa.
• The decisive figure is the strength ratio (achieved Rupas ÷ required Rupas); ≥ 1.0 means the planet meets its classical benchmark.
• The six components and totals are computed deterministically on the XALEN Ephemeris engine, not generated by a language model.
• Compute it via the flat /v2/astrology/* routes, or get a prose interpretation via POST /api/v1/astrology/query; stream interpretations via /api/v1/astrology/query/stream.
• The Vedika API exposes 700+ operations across 25 domains and runs Vedic, Western, and KP from one request surface.
• Definitions trace to BPHS, Phaladeepika, and Saravali.

Where to go next

Inspect the exact response shape for Shadbala and related strength tables in the free sandbox — no key required. When you are ready to provision a vk_live_ key, the tiers and per-query rates are on the pricing page, starting at $12/mo. Full request and response schemas for both the computation routes and the AI query endpoint are in the API documentation.