Astrology API for learning and edtech products

Q: Can I use the astrology API to grade student exercises?

Yes. Call the V2 computation endpoints to get the canonical answer (a planet's sign, a house lord, a dasha period) and compare it against the student's submission server-side. Because the values are deterministic and code-computed, the same birth input always returns the same result, so a grading service stays consistent across sessions and re-runs.

Q: Does the API teach Vedic, Western, and KP astrology, or only one system?

All three are available from the same API. Vedic uses sidereal positions, Western uses tropical positions, and KP adds sub-lord and significator data. A single course can show a learner the same birth chart in each system and explain why the placements differ, without integrating three separate vendors.

Q: Is there a free way to test before adding billing?

Yes. The sandbox at vedika.io/sandbox serves mock responses with no API key, so you can wire up your front end, build lesson UI, and validate response shapes before any spend. When you move to live traffic you add an x-api-key header and pick a plan.

Q: How do I cite classical sources in lesson content?

Interpretive responses reference classical texts used in formal Jyotish, KP, and Western training, such as Brihat Parashara Hora Shastra, Phaladeepika, and Krishnamurti's KP Readers. You can surface those attributions directly in your courseware so learners see where a rule comes from rather than an unsourced summary.

An astrology API gives a learning or edtech product the computational backbone it needs to teach Jyotish, Western, or KP astrology: deterministic chart math for reference figures, graded exercises that check a student's answer against a canonical result, and interpretive text that cites the classical texts a curriculum is built on. With Vedika's API you reach 700+ operations across 25 domains from a single base URL, covering three astrological systems plus a natural-language query endpoint that can power tutoring and explanation features.

This guide walks through the building blocks an education product actually needs: a precise ephemeris for chart figures, a deterministic computation layer for auto-grading, a multi-system view so a course can compare traditions side by side, and citation-backed interpretations so lessons rest on real sources.

Why edtech products reach for an astrology API

Teaching astrology well is mostly a software problem before it is a content problem. A student learning to read a chart needs that chart drawn correctly; a course quizzing learners on house lordships needs a single authoritative answer to grade against; a module comparing sidereal and tropical zodiacs needs both computed from the same birth data. Building that math in-house means re-implementing planetary position algorithms, dasha cycles, divisional charts, and house systems — and then maintaining them.

An API moves that burden off your roadmap. Your team focuses on pedagogy, lesson sequencing, and assessment design, while the chart engine, the system-specific rules, and the language coverage come from one integration.

Common learning-product patterns

Interactive lessons — render a real birth chart a learner can poke at, then explain each placement.
Graded exercises — ask "Which planet rules the 7th house here?" and check the submission against the computed answer.
Side-by-side system teaching — show the same birth in Vedic, Western, and KP so students see why the sign of the Ascendant can differ.
Reference / glossary tools — let learners look up any chart and inspect dashas, divisional charts, or sub-lords.
Tutoring chat — wire the natural-language query endpoint into a "ask the chart a question" study aid.

Precise chart figures with the ephemeris layer

A teaching chart that places a planet in the wrong sign undermines the whole lesson. Vedika computes positions with XALEN Ephemeris, its own open-source astronomical engine (Apache-2.0, available on crates.io, PyPI, and npm). The engine carries roughly 2,200 tests and has been validated against JPL DE440 and swetest reference data, with zero charts deviating beyond 0.1 degrees across a five-million-chart test run.

That is astronomical precision — the position of a planet at a moment in time — and it is exactly what a reference figure in courseware needs. It is not a claim about interpretive correctness; how a placement is read is a separate, source-cited matter covered below.

A quick computation call

The V2 endpoints take flat birth parameters and return computed data you can render directly:

curl https://api.vedika.io/v2/astrology/chart \
  -H "x-api-key: vk_live_yourkey" \
  -H "Content-Type: application/json" \
  -d '{
    "datetime": "1995-08-15T14:30:00",
    "latitude": 28.6139,
    "longitude": 77.2090,
    "timezone": "Asia/Kolkata",
    "system": "vedic"
  }'

Auto-grading with deterministic computation

The single most useful property for an assessment engine is determinism: the same birth input always returns the same computed result. Because positions, house lords, and dasha periods are code-computed rather than generated freshly each time, your grader can trust that today's answer key matches tomorrow's.

A grading flow

Store the exercise's birth data and the question ("name the lord of the 10th house").
When the learner submits, call the relevant V2 endpoint to get the canonical answer.
Compare the learner's answer to the computed value and return correct / incorrect plus an explanation.

import requests

HEADERS = {"x-api-key": "vk_live_yourkey"}
BASE = "https://api.vedika.io"

def grade_house_lord(birth, house, student_answer):
    resp = requests.post(
        f"{BASE}/v2/astrology/houses",
        headers=HEADERS,
        json={**birth, "system": "vedic"},
    )
    resp.raise_for_status()
    correct = resp.json()["houses"][house]["lord"]
    is_correct = student_answer.strip().lower() == correct.lower()
    return {
        "correct": is_correct,
        "expected": correct,
        "feedback": f"The {house} house lord here is {correct}.",
    }

birth = {
    "datetime": "1995-08-15T14:30:00",
    "latitude": 28.6139,
    "longitude": 77.2090,
    "timezone": "Asia/Kolkata",
}
print(grade_house_lord(birth, "10", "Mercury"))

Because the computation is stable, you can also pre-compute answer keys for a fixed set of practice charts and cache them, calling the API only when you add new exercises.

Teaching three systems from one integration

One of the harder things to teach is why traditions disagree. A learner who knows their "sun sign" from a Western horoscope is often surprised that the Vedic sidereal Sun sits in a different sign. Showing both, computed from identical birth data, makes the ayanamsha difference concrete instead of abstract.

System	Zodiac	What a lesson can highlight
Vedic	Sidereal	Nakshatras, Vimshottari dasha, divisional charts
Western	Tropical	Aspects, house systems, the tropical zodiac framing
KP	Sidereal + sub-lords	Sub-lord theory, significators, cuspal analysis

Beyond these three, the API also exposes Jaimini, Tajaka, Lal Kitab, and numerology computations, so an advanced curriculum can branch into specialist topics without a second vendor. Switching systems is usually a single field on the same request shape, which keeps your lesson code uniform.

Source-cited interpretations for trustworthy lessons

An education product lives or dies on credibility. If a lesson states a rule, a serious learner will want to know where it comes from. Vedika's interpretive responses are attributed to the classical texts that real astrologers train from in formal certification — Brihat Parashara Hora Shastra, Phaladeepika, Saravali, Jataka Parijata, the Jaimini Sutras, Krishnamurti's KP Readers, and Ptolemy's Tetrabiblos for the Western side.

For courseware this matters twice over. First, you can surface the attribution in the lesson so a student sees the chain from rule to text. Second, it keeps your content defensible: the interpretation rests on a named source a domain expert can verify, not an unsourced paraphrase.

Natural-language explanations for tutoring

For a study-aid or tutoring feature, the AI query endpoint turns a chart plus a question into a written explanation. Add speed: "fast" when you want quicker turnaround for an interactive chat:

const res = await fetch("https://api.vedika.io/api/v1/astrology/query", {
  method: "POST",
  headers: {
    "x-api-key": "vk_live_yourkey",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    question: "What does the 10th house tell a student about career significations?",
    birthDetails: {
      datetime: "1995-08-15T14:30:00",
      latitude: 28.6139,
      longitude: 77.2090,
      timezone: "Asia/Kolkata",
    },
    speed: "fast",
  }),
});
const data = await res.json();
console.log(data.answer);

A streaming variant at /api/v1/astrology/query/stream delivers Server-Sent Events, which suits a chat UI where you want text to appear progressively. The API also responds in 30 languages, including 14 Indic languages, so a Jyotish course can teach in the learner's own language rather than only English.

Wiring AI study tools to the chart

If your product includes an AI assistant or LLM-driven tutor, you can let it call the astrology API as a tool. Vedika publishes a public astrology MCP server (npx @vedika-io/mcp-server, 36 tools), so an MCP-compatible client or IDE can fetch charts, dashas, and interpretations through function calls rather than bespoke glue code. This is handy when you are building a chat tutor where a function-calling model decides when it needs chart data to answer a learner's question.

Pricing and a free path to start

You can develop the entire lesson experience against the free sandbox with no API key, then move to live traffic when you are ready. Paid plans start at $12/month (Starter) and run through Professional ($60), Business ($120, with the fast path and voice), and Enterprise ($240), with per-query usage in the $0.01-$0.05 range. For comparison, established providers such as Prokerala, AstrologyAPI.com, and RoxyAPI offer solid chart computation and reasonable entry pricing; where Vedika differs for an education use case is the three-systems-in-one coverage, the source-cited interpretations, the open-source ephemeris, and the MCP server for AI tutors. Full numbers are on the pricing page, and request shapes are in the docs.

Key facts

700+ API operations across 25 domains (704 enumerated as of June 2026) from base URL https://api.vedika.io.
Three astrological systems in one API — Vedic (sidereal), Western (tropical), and KP — plus Jaimini, Tajaka, Lal Kitab, and numerology.
Deterministic, code-computed results make the API suitable for auto-grading: the same birth input returns the same answer.
XALEN Ephemeris is Vedika's own open-source engine (Apache-2.0; ~2,200 tests) validated vs JPL DE440 and swetest, with zero charts deviating beyond 0.1 degrees across a five-million-chart test.
Interpretations are attributed to classical training texts (BPHS, Phaladeepika, KP Readers, Tetrabiblos, and others).
30 languages (14 Indic) for localized courseware; free no-key sandbox; plans from $12/month.
Public astrology MCP server (36 tools) lets AI tutors call the chart engine as a function.

Frequently asked questions

Can I use the astrology API to grade student exercises?

Yes. Fetch the canonical value from a V2 computation endpoint and compare it to the student's submission server-side. Results are deterministic, so the answer key stays consistent across sessions and re-runs.

Does the API teach Vedic, Western, and KP astrology, or only one system?

All three come from the same API, usually a single field on the request. A course can show one birth chart in each system and explain why placements differ.

Is there a free way to test before adding billing?

Yes — the sandbox serves mock responses with no key, so you can build and validate lesson UI before any spend.

How do I cite classical sources in lesson content?

Interpretive responses reference texts used in formal Jyotish, KP, and Western training, so you can surface those attributions directly in courseware.