White-label astrology API for agencies

If you run an agency and want to launch a branded astrology product without building an ephemeris engine or hiring astrologers, a white-label astrology API gives you the compute and the readings while you own the brand, the UI, and the client relationship. Vedika's API at https://api.vedika.io exposes 700+ operations across 25 domains, serves three astrology systems from one integration, and returns responses that do not surface any vendor or model names — so your clients see your product, not ours. This guide covers how white-labeling actually works in practice, the request shapes you'll integrate, language and system coverage, and where the cost lines fall.

What "white-label" means here

White-labeling is a product and integration decision, not a special tier. You call the API server-side with your secret key, transform the JSON into your own presentation layer, and never expose the upstream. There are three concrete properties that make this work cleanly:

• No vendor leakage in responses. Astronomical data is labelled as coming from the Vedika ephemeris engine, and AI-generated text is attributed to the Vedika engine — not to any third-party model or cloud provider. You can pass the JSON straight into your client-facing report without scrubbing provider strings.
• One base URL, your domain in front. You proxy from your own backend (for example readings.youragency.com/api) to api.vedika.io, keeping the key on your server and your domain on the wire your users see.
• You own the layout. The API returns structured chart data and narrative text. Your designers build the cards, PDFs, and dashboards. Nothing forces a Vedika look-and-feel into your product.

For an agency, the practical upshot is that a single Vedika account can sit behind several distinct client brands. You're not buying a template; you're buying the calculation and language layer.

One API, three systems — why that matters for agencies

Agencies rarely serve a single astrological tradition. A wellness brand may want Western tropical charts; a matrimony client in South India will expect KP and Vedic; a numerology app needs its own track. Vedika serves Vedic (sidereal), Western (tropical), and KP (Krishnamurti Paddhati) from the same endpoint, plus Jaimini, Tajaka, Lal Kitab, and numerology. You select the system per request, which means one integration and one billing relationship covers a portfolio of differently-positioned clients.

The astrological logic behind each system traces to the classical corpus that practitioners are actually trained on — Brihat Parashara Hora Shastra and Phaladeepika for Vedic, Krishnamurti's KP Readers for KP, and Ptolemy's Tetrabiblos for Western technique. That matters when a domain-expert client reviews your output: claims map to recognised texts rather than generic web summaries.

The ephemeris underneath

The astronomical layer is the XALEN Ephemeris, Vedika's own open-source engine (Apache-2.0, published on crates.io, PyPI, and npm). It carries roughly 2,200 tests and has been validated against JPL DE440 and the reference swetest tool, with no charts deviating beyond 0.1° across a five-million-chart test run. That is a statement about astronomical precision — planetary longitudes, ascendants, house cusps — not about whether an interpretation is "correct." For a white-label reseller it's a useful, checkable foundation: positions are deterministic and reproducible, so two requests for the same birth data always agree.

The endpoints you'll integrate

There are two layers most agencies use. The AI query endpoint returns a written reading; the V2 computation endpoints return structured chart data you can render yourself.

AI reading: POST /api/v1/astrology/query

This is the workhorse for a reading product. You send a natural-language question plus birth details and get back a narrative answer. Authentication is a header, x-api-key: vk_live_*.

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": "What does my chart say about career direction this year?",
    "birthDetails": {
      "datetime": "1992-03-14T09:25:00",
      "latitude": 19.0760,
      "longitude": 72.8777,
      "timezone": "Asia/Kolkata"
    },
    "language": "en"
  }'

Add "speed": "fast" when you want a lower-latency response for an interactive widget, and use the streaming variant when you want to render tokens as they arrive:

// Server-side proxy: keep your vk_live_ key off the client.
const res = await fetch(
  "https://api.vedika.io/api/v1/astrology/query/stream",
  {
    method: "POST",
    headers: {
      "x-api-key": process.env.VEDIKA_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      question: "Summarise my relationship outlook.",
      birthDetails: {
        datetime: "1990-11-02T14:10:00",
        latitude: 28.6139,
        longitude: 77.2090,
        timezone: "Asia/Kolkata",
      },
      language: "hi", // native Hindi output
    }),
  }
);

// res.body is a Server-Sent Events stream; pipe it to your client.
const reader = res.body.getReader();
const decoder = new TextDecoder();
for (;;) {
  const { value, done } = await reader.read();
  if (done) break;
  process.stdout.write(decoder.decode(value));
}

Structured charts: /v2/astrology/*

When you want to draw your own chart wheels, tables, or dashboards rather than show generated prose, the V2 computation endpoints return raw chart data. They take a flat input shape — datetime, latitude, longitude, timezone — instead of the nested birthDetails object:

import os, requests

resp = requests.post(
    "https://api.vedika.io/v2/astrology/chart",
    headers={"x-api-key": os.environ["VEDIKA_KEY"]},
    json={
        "datetime": "1988-07-21T06:45:00",
        "latitude": 13.0827,
        "longitude": 80.2707,
        "timezone": "Asia/Kolkata",
        "system": "vedic",  # or "western", "kp"
    },
    timeout=30,
)
chart = resp.json()
# Render chart["planets"], chart["houses"], chart["ascendant"] in your own UI.

Splitting work this way is the common agency pattern: structured V2 data feeds your branded chart renderer, and the v1 query endpoint supplies the written interpretation that sits beside it.

Languages: serving regional and multilingual markets

Readings can be produced in 30 languages, of which 14 are Indic — Hindi, Tamil, Telugu, Bengali, Marathi, Gujarati, Kannada, and more. The text is generated natively in the target language rather than machine-translated after the fact, which reads better for end users. For an agency, this is often the difference between a product that works only for an English audience and one that ships across regional markets from a single codebase. You pass the language code in the request; the rest of your integration stays identical.

Wiring it into AI assistants and agent tooling

If your agency builds AI assistants, chatbots, or copilots for clients, Vedika ships an MCP server (npx @vedika-io/mcp-server) that exposes 36 tools — chart computation, panchang, compatibility, and more — to any MCP-compatible client or IDE. That lets a function-calling model invoke real astrology computation as a tool rather than hallucinating planetary positions. The same masking applies: the model sees Vedika tools and Vedika data, not the infrastructure underneath. This is a clean way to add a verifiable astrology capability to an LLM agent product without writing chart math yourself.

Pricing and how agencies layer their margin

Vedika is subscription-plus-usage. The plan sets your monthly wallet and limits; per-query usage runs $0.01–$0.05 depending on the operation and speed path.

Because you control the client-facing price, your margin is the spread between what you charge per reading and the $0.01–$0.05 you pay. Established astrology APIs price differently — Prokerala starts around $19, AstrologyAPI.com around $29, and RoxyAPI around $39 — and each has real strengths in their own catalogue. Vedika's distinguishing points for a reseller are the three-systems-in-one integration, the 30-language native output, the open-source ephemeris you can independently verify, and responses engineered so no vendor identity leaks into your product. Compare the tiers on the pricing page before you size a plan.

A sensible integration path

1. Prototype against the sandbox. Build your UI and data model against the free mock endpoints at the sandbox with no key. The shapes match production.
2. Proxy from your backend. Move to a vk_live_ key, keep it server-side, and route through your own domain so the key never reaches the browser.
3. Pick your render split. Decide which screens use generated narrative (v1 query) and which draw structured charts (V2). Most products use both.
4. Localise. Flip the language parameter per client market; no code change beyond the request body.
5. Scale the plan to volume. Move up tiers as client load grows. Read the API docs for rate limits and the full operation catalogue.

Key facts

• Base URL https://api.vedika.io; auth via x-api-key: vk_live_*.
• 700+ operations across 25 domains (704 enumerated as of June 2026).
• Three systems in one API: Vedic (sidereal), Western (tropical), and KP — plus Jaimini, Tajaka, Lal Kitab, and numerology.
• Readings in 30 languages, including 14 Indic languages, generated natively.
• Responses surface no third-party vendor or model names — built for white-label resale.
• XALEN Ephemeris is open-source (Apache-2.0), with ~2,200 tests, validated against JPL DE440 and swetest within 0.1° across a five-million-chart test.
• MCP server (npx @vedika-io/mcp-server) exposes 36 tools to MCP-compatible clients.
• Plans $12–$240/month; per-query usage $0.01–$0.05; free sandbox with no key.

Frequently asked questions

Can I use the API under my own brand?

Yes. Responses do not expose the upstream compute vendor or model. You call the API server-side, render results in your own UI, and your end users see your brand.

Does one integration cover multiple astrology systems?

Yes — Vedic, Western, and KP all come from the same endpoint, selected per request, so one integration powers differently-positioned clients.

How do I try it without spending?

Use the free sandbox, which mirrors production request and response shapes with no API key required.

Which languages are supported?

Thirty languages, including 14 Indic languages, with text generated natively rather than translated after the fact.