deep-dive

Lal Kitab remedies and charts via API

Generate Lal Kitab charts, debt-of-planets analysis, and remedy guidance through the Vedika astrology API, with real endpoint shapes and code samples.

Yes, you can generate Lal Kitab charts and remedy guidance over a REST API. With Vedika, the interpretive Lal Kitab reading runs through POST /api/v1/astrology/query, where you pass a natural-language question plus the subject's birth details; the raw sidereal chart that Lal Kitab analysis depends on comes from the /v2/astrology/* computation endpoints. Both share one ephemeris engine, so the planetary positions behind a Lal Kitab reading are identical to those behind a classical Vedic or KP reading.

What Lal Kitab is, and why it needs its own treatment

Lal Kitab (the "Red Book") is a north-Indian school of astrology that emerged in the early twentieth century. It uses the same nine grahas and twelve houses as classical Jyotish, but it reorganizes interpretation around a house-centric model and a remedial system that is unusually concrete: practical upaya tied to specific planetary conditions rather than gemstones and elaborate rituals alone.

Two ideas make Lal Kitab distinct from a developer's point of view, because they change what you compute and surface:

Because the interpretive layer differs while the astronomical layer does not, a good API keeps the chart math in one place and lets you select the interpretive lens by how you frame the request.

The two endpoints you'll use

Vedika exposes 700+ operations across 25 domains (704 enumerated as of June 2026), but a Lal Kitab integration usually touches just two.

NeedEndpointReturns
Interpretation & remediesPOST /api/v1/astrology/queryNatural-language Lal Kitab reading grounded in the computed chart
Streaming interpretationPOST /api/v1/astrology/query/streamServer-Sent Events for token-by-token UI rendering
Raw chart dataGET/POST /v2/astrology/*Sidereal placements, house cusps, lordships you can render yourself

Authentication is a single header, x-api-key: vk_live_*, against the base URL https://api.vedika.io. The query path takes a nested birthDetails object; the V2 computation path takes flat datetime, latitude, longitude, and timezone fields.

A first Lal Kitab call with cURL

The fastest way to see the shape of a Lal Kitab response is to ask for it directly. Notice that you steer the system through the question text rather than a separate parameter.

curl -X POST https://api.vedika.io/api/v1/astrology/query \
  -H "Content-Type: application/json" \
  -H "x-api-key: vk_live_your_key_here" \
  -d '{
    "question": "Give a Lal Kitab analysis of my chart, including any rin (debt of planets) and the prescribed remedies.",
    "birthDetails": {
      "datetime": "1990-08-15T07:45:00",
      "latitude": 28.6139,
      "longitude": 77.2090,
      "timezone": "Asia/Kolkata"
    }
  }'

If you want the result to stream into a chat-style UI, point the same payload at /api/v1/astrology/query/stream and read the SSE event stream instead of a single JSON body.

Pulling the raw chart for your own renderer

Many teams want to draw the Lal Kitab kundli themselves — the characteristic north-Indian diamond grid with planets dropped into fixed houses — and only call the AI path for the written reading. For that, the V2 computation endpoints give you placements without interpretation. The flat field shape makes them easy to call from a typed client.

// Generic fetch — no SDK required. Swap in your own HTTP client if you prefer.
const BASE = "https://api.vedika.io";
const headers = {
  "Content-Type": "application/json",
  "x-api-key": process.env.VEDIKA_API_KEY,
};

async function lalKitabReading(birth) {
  // 1) Raw sidereal chart for your own grid renderer
  const chart = await fetch(`${BASE}/v2/astrology/chart`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      datetime: birth.datetime,        // "1990-08-15T07:45:00"
      latitude: birth.latitude,        // 28.6139
      longitude: birth.longitude,      // 77.2090
      timezone: birth.timezone,        // "Asia/Kolkata"
    }),
  }).then((r) => r.json());

  // 2) Written Lal Kitab interpretation + remedies
  const reading = await fetch(`${BASE}/api/v1/astrology/query`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      question: "Lal Kitab reading: house states, rin dosha, and remedies.",
      birthDetails: birth,
    }),
  }).then((r) => r.json());

  return { chart, reading };
}

The Python shape is the same pattern with a standard HTTP library:

import os, requests

BASE = "https://api.vedika.io"
HEADERS = {"x-api-key": os.environ["VEDIKA_API_KEY"]}

def lal_kitab(birth: dict) -> dict:
    reading = requests.post(
        f"{BASE}/api/v1/astrology/query",
        headers=HEADERS,
        json={
            "question": "Lal Kitab analysis with debt-of-planets and remedies.",
            "birthDetails": birth,
        },
    ).json()
    return reading

print(lal_kitab({
    "datetime": "1990-08-15T07:45:00",
    "latitude": 28.6139,
    "longitude": 77.2090,
    "timezone": "Asia/Kolkata",
}))

Where the chart numbers come from

Lal Kitab interpretation is only as trustworthy as the planetary positions under it. Vedika computes those with the XALEN Ephemeris, its own open-source engine published under Apache-2.0 (available as xalen on crates.io and PyPI, and @xalen/wasm on npm) with roughly 2,200 tests. The engine has been validated against JPL DE440 and against swetest, and across a five-million-chart sweep no chart deviated beyond 0.1 degrees.

To be precise about what that figure means: it is a statement of ephemeris precision — how closely the computed planetary longitudes match a reference astronomical model. It is not a claim about astrological accuracy, and it is not an endorsement by any space agency. What it buys you in practice is that the house a planet lands in, and therefore which Lal Kitab house-state applies, is stable and reproducible rather than drifting between runs or vendors.

Citations, remedies, and staying honest with users

Lal Kitab remedies are the part of the output users act on, so they deserve care. Vedika's interpretive layer is built to attribute astrological claims to recognized classical sources used in formal training — for general Jyotish that includes texts such as Brihat Parashara Hora Shastra, Phaladeepika, and Saravali, and for Lal Kitab the recognized Lal Kitab literature rather than blog paraphrases. The engineering goal is simple: an assertion the user sees should trace to a source, not to invented detail.

A few integration guidelines that keep your product on solid ground:

How the cost compares

Several established providers serve astrology data well. Prokerala (around $19/month) and AstrologyAPI.com (around $29/month) offer solid Vedic coverage, and RoxyAPI (around $39/month) is a capable computation source. Each is a reasonable choice if you mainly need raw calculations.

Vedika's plans run $12/month (Starter), $60 (Professional), $120 (Business, with the optional fast path and voice), and $240 (Enterprise), with per-query costs of roughly $0.01–$0.05. The differentiators worth weighing for a Lal Kitab build specifically:

Try it before you wire it in

You don't need a key to evaluate the Lal Kitab flow. The free sandbox mirrors the production request shapes so you can confirm the response structure, then move to a live key when you're ready. Full request and response schemas live in the API docs, plan limits are on the pricing page, and if you're comparing systems, the KP astrology API guide covers the same integration pattern for Krishnamurti Paddhati.

Key facts

FAQ

Can I generate a Lal Kitab chart through the Vedika API?

Yes. Use POST /api/v1/astrology/query for the interpretive reading and /v2/astrology/* for the raw placements you can render yourself. Both work in the free sandbox without a key.

How does Lal Kitab differ from standard Vedic astrology in the API?

It shares the same sidereal positions but applies a house-centric interpretive model — including blind, asleep, and exalted house states and a distinct remedy system. You select it through the question text; the chart math is shared.

Are the Lal Kitab remedies based on classical sources?

Yes. Astrological claims are attributed to recognized classical literature used in formal training rather than web summaries. Treat remedy output as informational guidance for your users.

What does it cost to call the Lal Kitab endpoints?

Plans run $12–$240/month with per-query costs of roughly $0.01–$0.05, and the sandbox is free for prototyping.

Build on the Vedika astrology API

700+ operations, Vedic + Western + KP, 30 languages, an open-source XALEN ephemeris, and a built-in LLM. Free sandbox — no signup.

Try the free sandbox