What is Ashtakavarga in Vedic astrology?

Ashtakavarga is a Vedic system described in Brihad Parashara Hora Shastra that assigns beneficial points (bindus) from 0 to 8 to each sign for each planet. The 8 contributors are the 7 classical planets plus the Lagna (ascendant). A planet transiting a sign with 4 or more bindus is generally beneficial; fewer indicates difficulty. Sarvashtakavarga totals all contributors for a comprehensive transit strength score.

Does Vedika API return Ashtakavarga data?

Yes. Vedika API's /v2/astrology/ashtakavarga endpoint returns a structured JSON object containing individual Ashtakavarga tables (Prastarashtakavarga) for all 8 contributors — Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, and Lagna — along with the Sarvashtakavarga (combined totals) for all 12 signs. Calculations use Swiss Ephemeris astronomical precision.

How do I combine Ashtakavarga with Dasha periods for timing predictions?

First fetch the Ashtakavarga data and identify the native's current Mahadasha and Antardasha lord using the /v2/astrology/vimshottari-dasha endpoint. Then score each upcoming month's transit for the dasha lord planet using its Ashtakavarga table. Months where the dasha lord transits a sign with 5+ bindus are generally favourable for predictions in the dasha-related domain (e.g., Jupiter dasha + Jupiter in high-bindu sign = expansion, finances, children).

What is the difference between Sarvashtakavarga and Prastarashtakavarga?

Prastarashtakavarga refers to the individual bindu table for a single planet — each planet has its own table of 12 sign scores contributed by the 8 sources. Sarvashtakavarga is the sum of all 8 individual tables, giving a single number per sign (0-56) representing the overall transit strength of any planet passing through that sign. Higher Sarvashtakavarga scores (above 28) indicate generally auspicious transits.

How much does Vedika API cost for Ashtakavarga access?

Ashtakavarga is included in all Vedika API subscription plans. Plans start at $12/month (Starter), $60/month (Professional), $120/month (Business), and $240/month (Enterprise with top-up credits). All plans include 140+ calculation endpoints, Swiss Ephemeris precision, and multi-language support across 30 languages.

Ashtakavarga API Guide: Transit Strength Analysis for Developers

Ashtakavarga is one of the most powerful transit analysis tools in Vedic astrology, and it is almost entirely absent from competing astrology APIs. Vedika API exposes the full Ashtakavarga system — individual planetary tables (Prastarashtakavarga) and the combined total (Sarvashtakavarga) — through a single endpoint, enabling developers to build transit strength dashboards, muhurta scorers, and timing engines without writing a line of ephemeris math.

This guide covers the theory behind Ashtakavarga, the exact API calls you need, and complete JavaScript code to build a transit strength dashboard that your users will actually find useful.

                What You Will Build: A JavaScript transit strength analyser that fetches Ashtakavarga data from Vedika API, renders a bindu table for each planet, scores upcoming transits, and highlights high-strength periods by combining with the native's active Dasha period.
            

Understanding Ashtakavarga

Described in Brihad Parashara Hora Shastra (BPHS), Ashtakavarga is a method for evaluating the strength of transiting planets. Each of the 7 classical planets (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn) plus the Lagna (ascendant) contributes a table of 12 values — one bindu (beneficial point) or zero per sign — based on its natal position and the transiting planet's position relative to it.

The result is that every sign holds a score from 0 to 8 for each transiting planet. These scores have a direct, rule-based interpretation per BPHS:

Bindu Score	Transit Strength	Typical Outcome
6–8	Excellent	High auspiciousness, clear results in that planet's significations
5	Good	Generally favourable; mixed if planet is debilitated
4	Average	Neutral; results depend on Dasha period
0–3	Weak	Obstacles, delays, adverse results in the planet's domain

Sarvashtakavarga vs Prastarashtakavarga

Prastarashtakavarga is the individual bindu table for a single planet. Each planet gets its own 12-sign table scored by the 8 contributors. This tells you precisely how strong a specific planet's transit through each sign is for this native.

Sarvashtakavarga sums all 8 individual tables to produce a single number per sign (range 0–56). This gives a general "overall auspiciousness" of any sign for any transiting planet. Signs above 28 are considered stronger-than-average transit zones.

Fetching Ashtakavarga Data from Vedika API

Vedika API's /v2/astrology/ashtakavarga endpoint returns the complete Ashtakavarga data set in a single call. You provide birth details; you receive every table pre-computed.

API Request

// fetch-ashtakavarga.js
const fetchAshtakavarga = async (birthDetails) => {
  const response = await fetch('https://api.vedika.io/v2/astrology/ashtakavarga', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': 'vk_live_YOUR_KEY_HERE'
    },
    body: JSON.stringify({
      datetime: birthDetails.datetime,   // ISO 8601: "1990-06-15T14:30:00"
      latitude: birthDetails.latitude,   // e.g. 28.6139 for Delhi
      longitude: birthDetails.longitude, // e.g. 77.2090 for Delhi
      timezone: birthDetails.timezone    // "+05:30" for IST
    })
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  return response.json();
};

// Example usage
const data = await fetchAshtakavarga({
  datetime: '1990-06-15T14:30:00',
  latitude: 28.6139,
  longitude: 77.2090,
  timezone: '+05:30'
});
            

API Response Structure

// Response JSON structure
{
  "success": true,
  "data": {
    "prastarashtakavarga": {
      "sun":     [4, 3, 5, 6, 2, 4, 3, 5, 4, 3, 6, 5],
      "moon":    [5, 4, 3, 5, 6, 3, 4, 2, 5, 4, 3, 6],
      "mars":    [3, 5, 4, 2, 4, 5, 3, 6, 3, 5, 4, 3],
      "mercury": [6, 4, 3, 5, 3, 4, 5, 3, 6, 4, 3, 4],
      "jupiter": [5, 6, 4, 3, 5, 4, 6, 3, 4, 5, 3, 4],
      "venus":   [4, 3, 6, 4, 5, 3, 4, 5, 3, 6, 4, 3],
      "saturn":  [3, 4, 5, 3, 4, 6, 3, 4, 5, 3, 5, 4],
      "lagna":   [5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 4, 3]
    },
    "sarvashtakavarga": [35, 32, 34, 33, 32, 33, 33, 31, 34, 35, 32, 32],
    "ascendant": { "sign": "Virgo", "degree": 12.4 },
    "planetaryPositions": {
      "jupiter": { "sign": "Cancer", "house": 11 }
    }
  }
}

// Array indices 0-11 correspond to signs: Aries, Taurus, Gemini, Cancer, Leo,
// Virgo, Libra, Scorpio, Sagittarius, Capricorn, Aquarius, Pisces
            

Building a Bindu Table Renderer

The following JavaScript function takes the Ashtakavarga API response and renders a colour-coded HTML table showing each planet's strength in every sign:

// bindu-renderer.js
const SIGNS = [
  'Aries', 'Taurus', 'Gemini', 'Cancer',
  'Leo', 'Virgo', 'Libra', 'Scorpio',
  'Sagittarius', 'Capricorn', 'Aquarius', 'Pisces'
];

const PLANETS = ['sun', 'moon', 'mars', 'mercury', 'jupiter', 'venus', 'saturn'];

function getBinduColor(score) {
  if (score >= 6) return '#16a34a';  // excellent — green
  if (score >= 5) return '#65a30d';  // good — lime
  if (score >= 4) return '#ca8a04';  // average — amber
  return '#dc2626';                   // weak — red
}

function renderBinduTable(ashtakavargaData) {
  const { prastarashtakavarga, sarvashtakavarga } = ashtakavargaData;

  let html = `
    <table class="bindu-table">
      <thead>
        <tr>
          <th>Planet</th>
          ${SIGNS.map(s => `<th>${s.slice(0,3)}</th>`).join('')}
          <th>Total</th>
        </tr>
      </thead>
      <tbody>
  `;

  for (const planet of PLANETS) {
    const scores = prastarashtakavarga[planet];
    const total = scores.reduce((a, b) => a + b, 0);
    html += `<tr><td><strong>${planet.charAt(0).toUpperCase() + planet.slice(1)}</strong></td>`;
    scores.forEach(score => {
      html += `<td style="color:${getBinduColor(score)};font-weight:bold">${score}</td>`;
    });
    html += `<td><strong>${total}</strong></td></tr>`;
  }

  // Sarvashtakavarga row
  html += `<tr style="background:#eef2ff"><td><strong>SAV Total</strong></td>`;
  sarvashtakavarga.forEach(score => {
    const color = score >= 30 ? '#16a34a' : score >= 25 ? '#ca8a04' : '#dc2626';
    html += `<td style="color:${color};font-weight:bold">${score}</td>`;
  });
  html += `<td><strong>${sarvashtakavarga.reduce((a,b)=>a+b,0)}</strong></td></tr>`;

  html += '</tbody></table>';
  return html;
}
            

Transit Strength Scoring Algorithm

Given the Ashtakavarga data and a planet's current transit sign, the scoring algorithm is straightforward:

// transit-scorer.js
const SIGN_INDEX = {
  aries: 0, taurus: 1, gemini: 2, cancer: 3,
  leo: 4, virgo: 5, libra: 6, scorpio: 7,
  sagittarius: 8, capricorn: 9, aquarius: 10, pisces: 11
};

function scoreTransit(planet, transitSign, prastarashtakavarga) {
  const signIdx = SIGN_INDEX[transitSign.toLowerCase()];
  if (signIdx === undefined) throw new Error(`Unknown sign: ${transitSign}`);

  const planetKey = planet.toLowerCase();
  if (!prastarashtakavarga[planetKey]) throw new Error(`Unknown planet: ${planet}`);

  const bindu = prastarashtakavarga[planetKey][signIdx];

  return {
    planet,
    transitSign,
    bindu,
    strength: bindu >= 6 ? 'Excellent' : bindu >= 5 ? 'Good' : bindu >= 4 ? 'Average' : 'Weak',
    interpretation: getInterpretation(planet, bindu)
  };
}

function getInterpretation(planet, bindu) {
  const interpretations = {
    jupiter: {
      high: 'Expansion, prosperity, wisdom, and growth in higher studies or spirituality.',
      low:  'Delayed results from Jupiter — avoid major financial decisions this transit.'
    },
    saturn: {
      high: 'Disciplined progress, long-term gains, recognition through hard work.',
      low:  'Sade Sati-like obstacles; delays, health issues for elderly, disputes.'
    },
    mars: {
      high: 'High energy, courage, success in competitive or technical fields.',
      low:  'Accidents, conflicts, aggression; avoid risky ventures.'
    },
    sun: {
      high: 'Authority, government favour, career advancement, father's wellbeing.',
      low:  'Ego conflicts with superiors; health of father may need attention.'
    },
    moon: {
      high: 'Emotional stability, public popularity, good for travel and social life.',
      low:  'Mental restlessness, relationship tensions; avoid major emotional decisions.'
    }
  };
  const p = interpretations[planet.toLowerCase()];
  if (!p) return `Bindu score ${bindu}/8 for this transit.`;
  return bindu >= 5 ? p.high : p.low;
}

// Example: Jupiter currently transiting Aries
const result = scoreTransit('Jupiter', 'Aries', data.prastarashtakavarga);
console.log(result);
// { planet: 'Jupiter', transitSign: 'Aries', bindu: 5, strength: 'Good', interpretation: '...' }
            

Combining Ashtakavarga with Dasha Periods

The real power of Ashtakavarga emerges when you combine transit bindus with the active Dasha period. A Jupiter Mahadasha native experiencing Jupiter transiting a high-bindu sign (5+) will see the Jupiter Dasha effects amplified significantly. Here is how to fetch both and correlate them:

// dasha-transit-correlator.js
async function getDashaTransitCorrelation(birthDetails) {
  // Fetch Ashtakavarga and Dasha in parallel
  const [avData, dashaData] = await Promise.all([
    fetchAshtakavarga(birthDetails),
    fetchDasha(birthDetails)
  ]);

  const { mahadasha, antardasha } = dashaData.data.currentDasha;
  const dashaPlanet = mahadasha.planet.toLowerCase();

  // Get current transit sign of the Mahadasha lord
  const currentTransitSign = dashaData.data.transitPositions[dashaPlanet].sign;

  const transitScore = scoreTransit(
    dashaPlanet,
    currentTransitSign,
    avData.data.prastarashtakavarga
  );

  return {
    mahadasha: mahadasha.planet,
    mahadashaEnd: mahadasha.endDate,
    antardasha: antardasha.planet,
    antardashaEnd: antardasha.endDate,
    dashaLordCurrentSign: currentTransitSign,
    transitStrength: transitScore.strength,
    bindu: transitScore.bindu,
    combinedReading: buildCombinedReading(mahadasha.planet, transitScore)
  };
}

async function fetchDasha(birthDetails) {
  const response = await fetch('https://api.vedika.io/v2/astrology/vimshottari-dasha', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': 'vk_live_YOUR_KEY_HERE'
    },
    body: JSON.stringify(birthDetails)
  });
  return response.json();
}

function buildCombinedReading(dashaPlanet, transitScore) {
  const { bindu, transitSign } = transitScore;
  if (bindu >= 5) {
    return `During this ${dashaPlanet} Mahadasha, ${dashaPlanet} is transiting `
         + `${transitSign} with ${bindu} bindus — a strong period. Expect amplified `
         + `results in ${dashaPlanet}-related areas: career, finance, and personal growth.`;
  }
  return `${dashaPlanet} Mahadasha is active, but ${dashaPlanet} transits ${transitSign} `
       + `with only ${bindu} bindus. Dasha results may be muted or delayed until `
       + `${dashaPlanet} moves to a higher-bindu sign.`;
}
            

Try Ashtakavarga with the Free Sandbox

65 mock endpoints, zero authentication required. Perfect for building and testing before committing to a plan.

Open Free Sandbox

Building a Monthly Transit Calendar

One practical application is a month-by-month transit calendar that shows the bindu score for Jupiter or Saturn (the two slowest classical planets, most impactful for annual predictions) as they move through signs:

// monthly-transit-calendar.js
// Jupiter's approximate sign change dates for 2026 (from Vedika API transit data)
const jupiterTransits2026 = [
  { month: 'Jan–Apr', sign: 'Gemini'  },
  { month: 'May–Aug', sign: 'Cancer'  },
  { month: 'Sep–Dec', sign: 'Cancer'  }
];

function buildTransitCalendar(transitPeriods, planet, prastarashtakavarga) {
  return transitPeriods.map(period => {
    const score = scoreTransit(planet, period.sign, prastarashtakavarga);
    return {
      period: period.month,
      sign: period.sign,
      bindu: score.bindu,
      strength: score.strength,
      recommendation: score.bindu >= 5
        ? 'Good window for ${planet}-related decisions'
        : 'Proceed cautiously on ${planet} matters'
    };
  });
}

const calendar = buildTransitCalendar(
  jupiterTransits2026,
  'Jupiter',
  avData.data.prastarashtakavarga
);

// Render to HTML table
function renderCalendar(calendar) {
  return `<table class="bindu-table">
    <thead>
      <tr><th>Period</th><th>Jupiter Sign</th><th>Bindus</th><th>Strength</th></tr>
    </thead>
    <tbody>
      ${calendar.map(row => `
        <tr>
          <td>${row.period}</td>
          <td>${row.sign}</td>
          <td style="color:${getBinduColor(row.bindu)};font-weight:bold">${row.bindu}</td>
          <td>${row.strength}</td>
        </tr>
      `).join('')}
    </tbody>
  </table>`;
}
            

Integrating with AI Narrative

Vedika API's AI endpoint can use the Ashtakavarga context to generate natural language transit interpretations. Simply pass the bindu scores as part of your question:

// ai-transit-narrative.js
async function getAITransitReading(birthDetails, ashtakavargaContext) {
  const { jupiterBinduInCurrentSign, currentJupiterSign, mahadasha } = ashtakavargaContext;

  const question = `Jupiter is transiting ${currentJupiterSign} with ${jupiterBinduInCurrentSign} `
    + `bindus in my Ashtakavarga. I am currently in ${mahadasha} Mahadasha. `
    + `What does this combination mean for my career and finances over the next 6 months?`;

  const response = await fetch('https://api.vedika.io/api/vedika/chat', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': 'vk_live_YOUR_KEY_HERE'
    },
    body: JSON.stringify({
      question,
      birthDetails: {
        datetime: birthDetails.datetime,
        latitude: birthDetails.latitude,
        longitude: birthDetails.longitude,
        timezone: birthDetails.timezone
      }
    })
  });

  const data = await response.json();
  return data.answer;
}
            

Why Vedika API for Ashtakavarga

BPHS-Verified

All Ashtakavarga calculations follow Brihad Parashara Hora Shastra rules exactly — same 8 contributors, same bindu assignment rules, verified against classical tables.

Swiss Ephemeris Precision

Planetary positions used for Ashtakavarga computation are calculated using astronomical-grade Swiss Ephemeris — the same engine used by professional Jyotish software.

Full Data in One Call

All 8 individual tables plus Sarvashtakavarga returned in a single API call. No repeated requests per planet.

AI Narrative Layer

The only astrology API with a built-in AI that can interpret Ashtakavarga data in natural language across 30 languages — including Hindi, Tamil, and Bengali.

140+ Endpoints

Combine Ashtakavarga with Dasha, Panchang, Yogas, Divisional Charts, Transit, and Muhurta endpoints — all in one subscription.

Starts at $12/month

Starter plan gives you full API access. Professional ($60), Business ($120), and Enterprise ($240) plans scale with usage.

Complete Integration Checklist

Fetch Ashtakavarga data with /v2/astrology/ashtakavarga
Render per-planet Prastarashtakavarga tables with colour-coded bindu scores
Display Sarvashtakavarga totals for overall sign strength
Score current transits for each planet using the bindu lookup
Fetch Dasha data from /v2/astrology/vimshottari-dasha and correlate Mahadasha lord transit bindu
Build a 12-month transit calendar for slow planets (Jupiter, Saturn)
Use the AI endpoint to generate natural language interpretations
Add multi-language support — Vedika API handles Hindi, Tamil, Bengali responses natively

Conclusion

Ashtakavarga is a system that separates professional Vedic astrology software from generic horoscope widgets. By exposing the full Prastarashtakavarga and Sarvashtakavarga through a clean REST API, Vedika makes it practical to build transit strength dashboards, personalized muhurta selectors, and Dasha-transit combination engines in hours, not weeks.

No other astrology API in the market returns the complete Ashtakavarga data set in a single call with Swiss Ephemeris precision and a built-in AI layer for natural language narrative generation. That combination is unique to Vedika.

Get started:

Create your API key at vedika.io/dashboard
Test with the free sandbox (no credit card)
Read the Ashtakavarga API reference
Combine with Dasha endpoints for timing predictions

About Vedika Intelligence: Vedika is the only B2B astrology API with AI-powered conversational capabilities, 140+ Vedic and Western calculation endpoints, and Swiss Ephemeris precision. Trusted by production apps worldwide, supporting 30 languages, starting at $12/month.

Ashtakavarga API: Transit Strength Analysis for Developers