DEV Community: Vedika Intelligence

Don't Make Users Wait: Building a Real-Time Astrology Reader with SSE and Vedika [2026-06]

Vedika Intelligence — Tue, 23 Jun 2026 03:30:49 +0000

We’ve all been there. You hit "Generate" on a tool, and for the next five seconds, the page is frozen. A loading spinner spins in a circle while the user wonders if their browser has crashed. In the world of Astrology, where insights are supposed to feel mystical, organic, and unfolding, a wall of static text arriving all at once feels jarring.

This is where Server-Sent Events (SSE) come in.

SSE is a web technology that allows a server to push data to a client in real-time. Unlike WebSockets (which are bi-directional), SSE is perfect for one-way streaming. It's lightweight, built into the browser (EventSource), and based on standard HTTP, making it incredibly easy to implement.

In this tutorial, we'll build a "Live Natal Chart Interpreter" that streams the AI-generated astrology reading from the Vedika Astrology API to the user in real-time.

The Problem with Synchronous Calls

Let's look at the standard approach. When you call the Vedika API (specifically POST /api/v1/astrology/query), you typically send a request and wait for a full JSON response.

// The "Bad" Way (Synchronous feel)
const response = await fetch('https://api.vedika.io/api/v1/astrology/query', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    question: "What does 2024 hold for me?",
    birthDetails: { datetime: "1990-01-01T00:00:00Z", lat: 28.6139, lng: 77.2090 }
  })
});

const data = await response.json();
console.log(data.insight); // Everything arrives at once

While this works, the UX is poor. The user has to stare at a blank screen or a spinner. With SSE, we can push the text to the user as the API (or our proxy) generates it, making the experience feel like a living conversation.

The Solution: Streaming the Insight

We will build a Node.js/Express server that acts as a bridge. The server will call the Vedika API, receive the response, and then "chunk" that response and send it to the client over an SSE connection.

Step 1: Project Setup

First, let's initialize our project and install dependencies.

npm init -y
npm install express cors axios

Step 2: The Backend (Express + SSE)

We need a route that accepts a POST request and sets the appropriate headers for SSE (Content-Type: text/event-stream and Cache-Control: no-cache).

Here is the server code (index.js):


javascript
const express = require('express');
const axios = require('axios');
const

Getting Started with Vedika Astrology API [2026-06]

Vedika Intelligence — Tue, 16 Jun 2026 03:30:56 +0000

Building astrology features into your app? Here's a quick walkthrough using the Vedika API.

The Problem

Adding accurate Vedic astrology calculations to your product typically requires deep domain expertise and months of development. Vedika provides a single API endpoint that handles all of it.

Quick Start

curl -X POST https://api.vedika.io/v2/astrology/kundli \
  -H "x-api-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"datetime": "1990-06-15T10:30:00", "latitude": 12.9716, "longitude": 77.5946, "timezone": "+05:30"}'

What You Get

45+ Vedic astrology endpoints (Kundli, Dasha, Muhurta, matchmaking)
Swiss Ephemeris precision calculations
AI-powered interpretations
Sub-100ms response times

Try It Free

The sandbox at vedika.io/sandbox lets you test all 65 endpoints with mock data — no API key needed.

Check out the full docs at vedika.io/docs.

Getting Started with Vedika Astrology API [2026-04]

Vedika Intelligence — Tue, 21 Apr 2026 03:31:44 +0000

Building astrology features into your app? Here's a quick walkthrough using the Vedika API.

The Problem

Adding accurate Vedic astrology calculations to your product typically requires deep domain expertise and months of development. Vedika provides a single API endpoint that handles all of it.

Quick Start

curl -X POST https://api.vedika.io/v2/astrology/kundli \
  -H "x-api-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"datetime": "1990-06-15T10:30:00", "latitude": 12.9716, "longitude": 77.5946, "timezone": "+05:30"}'

What You Get

45+ Vedic astrology endpoints (Kundli, Dasha, Muhurta, matchmaking)
Swiss Ephemeris precision calculations
AI-powered interpretations
Sub-100ms response times

Try It Free

The sandbox at vedika.io/sandbox lets you test all 65 endpoints with mock data — no API key needed.

Check out the full docs at vedika.io/docs.

React + Vedika: Building an Intelligent Horoscope Query Tool in 10 Minutes [2026-04]

Vedika Intelligence — Tue, 14 Apr 2026 03:30:24 +0000

The Problem: Static Text vs. Dynamic AI Insights

Building a web application around astrology used to mean two things: either scraping static horoscope pages (which are often inaccurate and outdated) or building a massive Vedic mathematics engine from scratch (which is computationally expensive and prone to bugs).

Modern web applications demand dynamic content. Users don't just want to see their "Sun Sign"; they want to know, "Will I get a promotion this year?" or "Should I move to a new city based on my Dasha?".

This is where the Vedika API comes in. It provides a single, powerful endpoint that uses AI to interpret Vedic astrology charts based on user inputs. In this tutorial, we will integrate this API into a modern React application to create a real-time, interactive astrology query tool.

Prerequisites

Before we dive into the code, ensure you have:

Node.js installed.
A basic understanding of React Hooks (useState, useEffect).
A free API key from the Vedika Sandbox.

Step 1: Project Setup

We’ll use Vite for this tutorial because it offers a faster build setup and modern tooling. Open your terminal and run:

npm create vite@latest vedika-astro-app -- --template react
cd vedika-astro-app
npm install

Step 2: Understanding the API Payload

The Vedika API expects a specific JSON structure. To use it effectively in React, we need to define our data types.

According to the documentation, the endpoint is POST /api/v1/astrology/query.

The Request Body:

{
  "question": "Will I get a job offer next month?",
  "birthDetails": {
    "datetime": "1990-05-15T10:30:00Z", // ISO 8601 format
    "lat": 28.6139, // Latitude
    "lng": 77.2090  // Longitude
  }
}

Step 3: Creating a Custom Hook

In a professional React application, we never put API logic directly inside our UI components. Instead, we extract it into a custom hook. This keeps our code clean, reusable, and testable.

Create a file named useVedikaQuery.js (or .ts if you prefer TypeScript).


javascript
import { useState } from 'react';

const VEDIKA_API_URL = 'https://api.vedika.io/api/v1/astrology/query';

export const useVedikaQuery = () => {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  const [data, setData] = useState(null);

  const queryAstrology = async (question, birthDetails) => {
    setLoading(true);
    setError(null);

    try {
      const response = await fetch(VEDIKA_API_URL, {
        method: 'POST',
        headers: {
          'Content

Stop Guessing Your JSON: Building Type-Safe APIs with TypeScript and Vedika [2026-04]

Vedika Intelligence — Tue, 07 Apr 2026 03:30:28 +0000

If you’ve been writing TypeScript for any amount of time, you know the pain of the any keyword. It’s the siren song of convenience—easy to type, but a disaster waiting to happen at runtime. One day, your API returns a string when you expect an object, or a field you thought was required is suddenly missing.

When integrating with external APIs, especially AI-driven ones, this uncertainty is amplified. The response structure might be complex, nested, or evolve without notice. This is where TypeScript shines. It allows us to define a contract before the data hits the wire, ensuring our application is robust, maintainable, and predictable.

In this article, we’ll integrate the Vedika Astrology API into a TypeScript application. We will focus on the "how" and the "why," demonstrating how to build a type-safe client that queries for astrological insights based on birth details.

The Setup

Before we write any code, we need a target. The Vedika API is an AI-powered Vedic astrology service. It requires a single endpoint, POST /api/v1/astrology/query, which takes a question and birth details to generate a reading.

For this example, we’ll assume you have a Node.js environment set up. Create a new folder, initialize a project, and install fetch (built-in in Node 18+) or axios. For strict typing, we’ll stick to the native fetch API to keep dependencies low.

mkdir vedika-ts-client
cd vedika-ts-client
npm init -y

Step 1: Define Your Types

The first rule of TypeScript integration is: Define the Shape.

We need to map the JSON structure of the Vedika API request and response to TypeScript interfaces. This happens in two parts: defining the Request payload and defining the Response payload.

1.1 The Request Interface

The API requires a question (string) and a birthDetails object. The birthDetails object needs a datetime (ISO 8601 string), latitude, and longitude.

// types.ts

export interface BirthDetails {
  datetime: string; // ISO 8601 format, e.g., "2000-01-01T12:00:00Z"
  lat: number;
  lng: number;
}

export interface AstrologyQueryRequest {
  question: string;
  birthDetails: BirthDetails;
}

1.2 The Response Interface

The API returns a JSON object. While the exact field names might vary slightly depending on the specific AI model version, we anticipate a structure containing an insight field and metadata.

export interface AstrologyResponse {
  insight: string;
  // Future-proofing: Adding other potential fields as comments
  // timestamp?: number;
  // confidence?: number;
}

By defining these interfaces, we gain immediate feedback. If you misspell datetime as date, TypeScript will scream at you immediately in your IDE.

Step 2: Implementing the Client

Now that our types are defined, we can build the client. We will create a function that accepts the AstrologyQueryRequest, sends

Stop Burning API Quotas: A Practical Guide to Caching the Vedika Astrology API [2026-03]

Vedika Intelligence — Tue, 31 Mar 2026 03:30:36 +0000

Astrology applications are a goldmine for developers, but they are also a nightmare for API budgets. Why? Because every single user query triggers an AI generation process.

Imagine a user asking: "Will I get married?" followed by "When?" and "Who will I marry?" If you fetch the answer from the Vedika API for every single request, you are paying for the same AI processing three times.

In this article, we will solve this performance bottleneck by implementing robust caching strategies for the Vedika Astrology API. We'll move from simple in-memory caching to time-based expiration, ensuring your app is fast, cost-effective, and scalable.

The Problem: Why We Can't Just "Fetch and Forget"

The Vedika API is powerful. It uses advanced Vedic astrological principles and AI to generate personalized insights. However, this comes at a cost.

Latency: AI generation takes time. Waiting 2-3 seconds for every query degrades the user experience.
Cost: Every request to the AI model consumes credits. Repetitive queries (like a user refreshing their dashboard) drain your budget.
Scalability: As traffic increases, your backend servers will spend more time waiting for external API responses instead of serving users.

The solution? Caching. We store the result of a query locally (or in a database) so we can return it instantly if the same question is asked again.

Step 1: Simple In-Memory Caching

The easiest way to start is with in-memory caching. In Node.js, we can use a Map object to store our results.

The Logic

Check if the answer exists in the Map.
If yes, return the cached data immediately.
If no, call the Vedika API, save the response to the Map, and then return it.

The Code

Here is a TypeScript implementation using the Vedika endpoint (POST /api/v1/astrology/query).


typescript
interface BirthDetails {
  datetime: string;
  lat: number;
  lng: number;
}

interface AstrologyResponse {
  insight: string;
  confidence: number;
}

class AstrologyService {
  private cache = new Map<string, AstrologyResponse>();

  // A helper to generate a unique key from the user's query
  private generateCacheKey(question: string, birthDetails: BirthDetails): string {
    // We normalize the input so "Will I get married?" and "Will I get married?" 
    // are treated as the same query.
    return `${question}-${birthDetails.datetime}`;
  }

  public async getInsight(
    question: string, 
    birthDetails: BirthDetails
  ): Promise<AstrologyResponse> {
    const cacheKey = this.generateCacheKey(question, birthDetails);

    // 1. Check Cache
    if (this.cache.has(cacheKey)) {
      console.log(`[Cache Hit] Returning data for: ${question}`);
      return this.cache.get(cacheKey)!;
    }

    console.log(`[Cache Miss] Fetching from Vedika API for: ${question}`);

    // 2. Fetch from API
    // Note: In

From Zero to Horoscope: Building a TypeScript Client for Vedic Astrology [2026-03]

Vedika Intelligence — Tue, 24 Mar 2026 03:30:31 +0000

When we talk about API integration in TypeScript, we rarely discuss the mystical. Usually, it’s CRUD operations, financial data, or weather forecasts. But sometimes, you want to build something a little more... esoteric.

Enter the Vedika API. It’s an AI-powered Vedic astrology service. It solves a specific problem: you feed it a question and a birth chart (date, time, location), and it generates an AI-driven insight.

For a TypeScript developer, integrating this isn't just about making a POST request. It's about rigorously defining the shape of the cosmos (and the data) before you actually ask it a question.

In this post, we’ll build a type-safe client from scratch. We’ll focus on how to structure your interfaces, handle async operations, and catch the edge cases that usually break production apps.

The Problem: The "Any" Trap

Before we write code, let’s look at the friction point. If you simply use any in TypeScript, you bypass the compiler's safety net.

// ❌ The dangerous way
async function getHoroscope(question: string) {
  const res = await fetch('...');
  const data = await res.json(); // TypeScript thinks data is any
  return data.prediction; // 💥 Runtime crash if the API changes
}

If the API response structure shifts slightly (which happens often during AI model training), your app crashes.

The Solution: Strongly Typed Interfaces

The Vedika API has a single endpoint: POST /api/v1/astrology/query.

To make this robust, we need to define what the input looks like and what the output looks like.

1. Defining the Data Shapes

First, let's define the input structure. The API expects a question string and a birthDetails object containing date, latitude, and longitude.

// types.ts

/**
 * Represents the geographic location of birth.
 * Using strict number types for coordinates.
 */
interface BirthDetails {
  date: string; // ISO 8601 format: YYYY-MM-DD
  time: string; // ISO 8601 format: HH:mm:ss
  lat: number;
  lng: number;
}

/**
 * The request payload for the Vedika API.
 */
interface AstrologyQueryRequest {
  question: string;
  birthDetails: BirthDetails;
}

/**
 * The expected response structure from Vedika.
 * We use 'unknown' initially to force us to handle the data explicitly.
 */
interface AstrologyResponse {
  prediction: string;
  planetary_positions?: Record<string, string>;
  remedial_measures?: string[];
  error?: string;
}

Notice we used string for dates. In JSON (which APIs communicate over), dates are rarely objects. They are serialized strings. If we tried to use a native Date object in the interface, we would have to deal with serialization logic manually every time we sent the request.

2. The Client Class

Now, let's wrap the fetch logic in a class. This encapsulates our configuration and error handling.

Building an AI-Powered Astrology Dashboard in React: A Practical Guide [2026-03]

Vedika Intelligence — Tue, 17 Mar 2026 03:31:05 +0000

The intersection of traditional knowledge and modern technology has always been fascinating. In the world of Vedic astrology, this intersection is currently being revolutionized by Artificial Intelligence. But for frontend developers, integrating complex logic like planetary calculations and predictive analytics can be a nightmare.

You don't want to build a physics engine to calculate the position of Jupiter in the sign of Cancer based on a user's birth time and location. You want to focus on the UI and the user experience.

This is where Vedika comes in. Vedika is an AI-powered Vedic astrology API that abstracts away the complexity. It takes simple inputs—like a question and birth details—and returns AI-generated insights.

In this tutorial, we will build a sleek, functional React application that queries the Vedika API to generate personalized astrological readings.

Prerequisites

Before we dive in, ensure you have the following:

Node.js installed on your machine.
Basic knowledge of React and hooks (useState, useEffect).
An API key from the Vedika Sandbox (it's free and requires no credit card).

Step 1: Project Initialization

Let's kick things off by setting up a standard React project using Vite. It’s faster and more modern than Create React App.

Open your terminal and run:

npm create vite@latest vedika-dashboard -- --template react
cd vedika-dashboard
npm install
npm run dev

Now, let's focus on the logic. We need a dedicated file to handle our API communication.

Step 2: The API Client

The Vedika API is simple: a single POST endpoint at /api/v1/astrology/query.

We need to construct the request body carefully. Based on the Vedika documentation, the input expects a question string and a birthDetails object containing datetime, lat, and lng.

Create a new file named vedikaService.js in your src folder:

// src/vedikaService.js

const SANDBOX_URL = 'https://api.vedika.io/api/v1/astrology/query';

export const queryVedika = async (question, birthDetails) => {
  try {
    const response = await fetch(SANDBOX_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // In production, you would use a real API key here
        // 'Authorization': 'Bearer YOUR_API_KEY'
      },
      body: JSON.stringify({
        question: question,
        birthDetails: {
          datetime: birthDetails.datetime, // Format: YYYY-MM-DDTHH:mm
          lat: birthDetails.lat,
          lng: birthDetails.lng
        }
      })
    });

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

    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Vedika API Error:', error);
    throw error;
  }
};

Pro Tip: Notice that we are using the SANDBOX_URL. The documentation states that the sandbox

Building an Astrology API with 140+ Vedic Endpoints: How We Built Vedika

Vedika Intelligence — Sat, 14 Mar 2026 02:18:46 +0000

Every astrology app you've ever used -- Co-Star, The Pattern, AstroSage -- relies on the same foundation: planetary calculations, birth chart analysis, and interpretation logic. Building this from scratch takes 6-12 months and deep expertise in both astronomy and Vedic texts.

We built Vedika so you don't have to.

What is Vedika?

Vedika is a purpose-built astrology intelligence API. It combines Swiss Ephemeris-grade astronomical calculations with an AI interpretation layer that understands natural language questions about birth charts.

Instead of calling 5 separate endpoints and writing interpretation logic yourself, you send one query:

"What are my career prospects this year?"

Vedika figures out which calculations to run (10th house analysis, Mahadasha timing, Jupiter transit, Dashamsha chart), executes them, and returns a coherent answer.

The numbers:

140+ Vedic astrology calculation endpoints
15 Western astrology endpoints
AI chatbot supporting 30 languages
65 sandbox endpoints for free testing
Sub-200ms response times on calculation endpoints

Architecture: Why This Was Hard to Build

Three things make astrology APIs genuinely difficult:

1. Astronomical Precision

Planetary positions must be accurate to arc-minutes. We use Swiss Ephemeris (the same library used by professional astronomical software) compiled into our backend. Every position is computed in-house -- no external API calls for Vedic calculations.

Swiss Ephemeris -> Julian Day conversion -> Sidereal correction (Lahiri ayanamsa)
-> House calculation (Whole Sign) -> Planetary dignities -> Yoga detection

2. Classical Rule Systems

Vedic astrology has thousands of rules from texts written 2,000+ years ago (BPHS, Phaladeepika, Saravali). Our codebase implements:

21 yoga detection algorithms (Gaja Kesari, Budha-Aditya, Pancha Mahapurusha, etc.)
Vimshottari Dasha system with Mahadasha/Antardasha/Pratyantar periods
Ashtakavarga scoring across all planets
Shadbala (6-fold planetary strength)
Mangal Dosha, Kaal Sarp Dosha detection
Divisional charts: Navamsa (D9), Dashamsha (D10), and more

Each rule was verified against classical source texts. Not approximated -- verified.

3. Anti-Hallucination

The AI interpretation layer can never contradict computed data. We built a 4-layer validation pipeline:

Chart Summary -- Code-generated markdown with all planetary positions, dignities, aspects, yogas (math only, no AI)
AI Instructions -- 11 mandatory rules the AI must follow (never fabricate yogas, never guess nakshatras)
Mandatory Facts -- Verified data injected into every prompt
Response Validator -- Post-AI checking that catches sign/house/degree errors before delivery

If the AI says "Jupiter is exalted" but the computed data shows Jupiter in Capricorn (debilitated), the validator catches and corrects it.

Code Examples

curl -- Get a Birth Chart

curl -X POST https://api.vedika.io/v2/astrology/birth-chart \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "datetime": "1990-06-15T14:30:00+05:30",
    "latitude": 28.6139,
    "longitude": 77.2090
  }'

Response includes: All 9 planets with sign, house, degree, nakshatra, dignity (exalted/debilitated/own/moolatrikona), retrograde status, combustion flags, plus house cusps and active yogas.

JavaScript SDK

npm install @vedika-io/sdk

import { VedikaClient } from '@vedika-io/sdk';

const client = new VedikaClient({ apiKey: 'vk_live_...' });

// Ask a natural language question
const response = await client.askQuestion({
  question: 'What are my career prospects this year?',
  birthDetails: {
    datetime: '1990-06-15T14:30:00+05:30',
    latitude: 28.6139,
    longitude: 77.2090
  }
});

console.log(response.answer);
// "Your 10th house lord Jupiter is currently transiting through
//  your 9th house, activating a strong Dharma-Karmadhipati yoga..."

Python SDK

pip install vedika-sdk

from vedika import VedikaClient

client = VedikaClient(api_key='vk_live_...')

# Get Kundli matching for matrimonial platforms
match = client.kundli_matching(
    boy_details={
        'datetime': '1992-03-15T10:00:00+05:30',
        'latitude': 19.0760,
        'longitude': 72.8777
    },
    girl_details={
        'datetime': '1994-07-22T14:30:00+05:30',
        'latitude': 28.6139,
        'longitude': 77.2090
    }
)

print(f"Guna Score: {match['gunaScore']}/36")
print(f"Mangal Dosha: Boy={match['boyMangalDosha']}, Girl={match['girlMangalDosha']}")

AI Chat with Streaming (SSE)

const response = await fetch('https://api.vedika.io/api/v1/astrology/query/stream', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': 'vk_live_...'
  },
  body: JSON.stringify({
    question: 'Explain my current Mahadasha and what to expect',
    birthDetails: {
      datetime: '1995-11-20T08:15:00+05:30',
      latitude: 13.0827,
      longitude: 80.2707
    }
  })
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  const chunk = decoder.decode(value);
  process.stdout.write(chunk); // Stream to UI in real-time
}

Key Endpoints

Here's a sampling of what's available:

Category	Endpoints	What They Calculate
Birth Chart	`/v2/astrology/birth-chart`, `/kundli`	Planets, houses, aspects, yogas
Dasha	`/v2/astrology/vimshottari-dasha`, `/antardasha`	Planetary periods with exact dates
Compatibility	`/v2/astrology/guna-milan`, `/ashtakoot-match`	36-point Guna matching
Panchang	`/v2/astrology/panchang`, `/choghadiya`	Daily almanac, muhurta timing
Doshas	`/v2/astrology/mangal-dosha`, `/kaal-sarp-dosha`	Dosha detection with remedies
Predictions	`/v2/astrology/horoscope/daily`, `/weekly`, `/monthly`	AI-generated predictions
Divisional	`/v2/astrology/navamsa`, `/dashamsa`	D9, D10, and other varga charts
Numerology	`/v2/astrology/numerology/life-path`, `/destiny`	Name and date numerology
AI Chat	`/api/v1/astrology/query`	Natural language astrology Q&A
Western	`/v2/western/natal-chart`, `/transit-chart`	Tropical zodiac, Western aspects

All endpoints accept the same birth data format. All return structured JSON.

Use Cases (Who's Building With This)

Matrimonial Platforms

Kundli matching is table stakes for Indian matrimonial sites. Vedika's /v2/astrology/guna-milan endpoint returns the 36-point Ashtakoot score, individual Guna breakdowns, Mangal Dosha status for both partners, and compatibility analysis -- in one call.

Horoscope & Rashifal Apps

Daily/weekly/monthly predictions for all 12 signs. The prediction endpoints return structured JSON with scores (1-10) across career, love, health, and finance categories. Perfect for building rashifal sections in news apps or standalone horoscope apps.

Wellness & Spiritual Platforms

Panchang data, muhurta timing, gemstone recommendations, and remedies. Apps like meditation timers and spiritual wellness platforms use this to add personalized astrology features.

AI Chatbot Integrations

The AI chat endpoint turns any app into an astrology consultation platform. Users ask questions in natural language (in 30 languages), and get personalized answers grounded in their actual birth chart data. No astrology knowledge required on your side.

MCP Server for AI Agents

Vedika ships an MCP Server with 22 tools. AI agents in Claude Desktop, Cursor, or Windsurf can natively call astrology calculations:

{
  "mcpServers": {
    "vedika": {
      "command": "npx",
      "args": ["-y", "@vedika-io/mcp-server"],
      "env": { "VEDIKA_API_KEY": "vk_live_your_key_here" }
    }
  }
}

Getting Started

1. Try the Sandbox (No API Key Needed)

65 mock endpoints are available at https://api.vedika.io/sandbox/ for free testing. Same request format as production, realistic response structures.

curl https://api.vedika.io/sandbox/v2/astrology/birth-chart \
  -H "Content-Type: application/json" \
  -d '{"datetime":"1990-01-01T12:00:00+05:30","latitude":28.61,"longitude":77.20}'

2. Get an API Key

3. Choose Your Plan

Vedika uses a wallet-based credit system:

Plan	Monthly	Best For
Starter	$12/mo	Side projects, MVPs
Pro	$60/mo	Production apps
Business	$120/mo	High-traffic apps
Enterprise	$240/mo	Scale platforms

Calculation endpoints cost $0.001-$0.010 per call. AI chat queries cost more (they run actual inference). No surprise bills -- when your wallet hits zero, calls return 402 until you renew.

4. Read the Docs

API Reference: vedika.io/docs
JavaScript SDK: @vedika-io/sdk on npm
Python SDK: vedika-sdk on PyPI
MCP Server: @vedika-io/mcp-server on npm
GitHub: github.com/vedika-io

Build vs. Buy: The Honest Comparison

Factor	Build from Scratch	Use Vedika API
Development time	6-12 months	30 minutes
Swiss Ephemeris integration	Complex C bindings	Handled
BPHS rule implementation	Months of research	21 yogas pre-built
AI interpretation	Train your own model	Included
Multi-language	Build translation layer	30 languages built-in
Maintenance	Ongoing ephemeris updates	Handled
Cost	$50K-$200K engineering	$12/month

If you're building an astrology product, your competitive advantage is the user experience, not the planetary calculation engine. Use Vedika for the hard math. Build the product your users actually want.

Links:

Website: vedika.io
API Console: vedika.io/console
Documentation: vedika.io/docs
GitHub: github.com/vedika-io

Getting Started with Vedika Astrology API [2026-03]

Vedika Intelligence — Tue, 10 Mar 2026 03:31:49 +0000

Building astrology features into your app? Here's a quick walkthrough using the Vedika API.

The Problem

Adding accurate Vedic astrology calculations to your product typically requires deep domain expertise and months of development. Vedika provides a single API endpoint that handles all of it.

Quick Start

curl -X POST https://api.vedika.io/v2/astrology/kundli \
  -H "x-api-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"datetime": "1990-06-15T10:30:00", "latitude": 12.9716, "longitude": 77.5946, "timezone": "+05:30"}'

What You Get

45+ Vedic astrology endpoints (Kundli, Dasha, Muhurta, matchmaking)
Swiss Ephemeris precision calculations
AI-powered interpretations
Sub-100ms response times

Try It Free

The sandbox at vedika.io/sandbox lets you test all 65 endpoints with mock data — no API key needed.

Check out the full docs at vedika.io/docs.

Getting Started with Vedika Astrology API [2026-03]

Vedika Intelligence — Tue, 03 Mar 2026 03:30:21 +0000

Building astrology features into your app? Here's a quick walkthrough using the Vedika API.

The Problem

Adding accurate Vedic astrology calculations to your product typically requires deep domain expertise and months of development. Vedika provides a single API endpoint that handles all of it.

Quick Start

curl -X POST https://api.vedika.io/v2/astrology/kundli \
  -H "x-api-key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"datetime": "1990-06-15T10:30:00", "latitude": 12.9716, "longitude": 77.5946, "timezone": "+05:30"}'

What You Get

45+ Vedic astrology endpoints (Kundli, Dasha, Muhurta, matchmaking)
Swiss Ephemeris precision calculations
AI-powered interpretations
Sub-100ms response times

Try It Free

The sandbox at vedika.io/sandbox lets you test all 65 endpoints with mock data — no API key needed.

Check out the full docs at vedika.io/docs.

Beyond JSON: Building Type-Safe API Integrations with TypeScript and Vedika [2026-02]

Vedika Intelligence — Tue, 24 Feb 2026 03:30:45 +0000

When we start building applications, we often treat API integration as a simple "fetch and print" task. We send a JSON object, get a JSON response, and move on. However, as applications grow, relying on loose typing (any) leads to runtime errors that are incredibly frustrating to debug.

In this article, we’re going to build a robust, type-safe integration for the Vedika Astrology API. While the domain (Vedic astrology) might seem niche, the technical requirements—specifically handling datetime objects, geospatial coordinates, and unstructured AI responses—make it a perfect playground for demonstrating TypeScript's power.

The Problem: The "Any" Trap

Consider a naive implementation:

const response = await fetch('/api/astrology', {
  method: 'POST',
  body: JSON.stringify({
    question: "When will I get a promotion?",
    birthDetails: {
      // What type is this? What happens if I miss a field?
    }
  })
});

const data = await response.json();
console.log(data.insights); // Runtime crash if 'insights' is missing

This code is brittle. If you misspell insights as insights, TypeScript won't stop you, and you’ll get a runtime error. If the API changes its structure, your code breaks silently until a user encounters the issue.

The Solution: Strict Interfaces

To solve this, we must define exactly what the API expects and what it returns. We will use TypeScript interfaces to enforce this contract.

Step 1: Define the Data Structures

Vedika requires two main inputs: a question string and birthDetails (which includes a datetime, latitude, and longitude).

First, let's define the BirthDetails interface. This ensures we capture the location and time accurately.

interface BirthDetails {
  datetime: string; // ISO 8601 format is standard
  lat: number;
  lng: number;
}

Next, let's define the request payload.

interface VedikaQueryInput {
  question: string;
  birthDetails: BirthDetails;
}

Step 2: Define the Response Schema

The API returns an AI-generated response. We need to anticipate what that looks like. We'll define an interface for the root response, likely containing an array of insights or an analysis object.

interface VedikaResponse {
  success: boolean;
  data: {
    insights: string[]; // Array of string insights
    summary: string;
  } | null;
  error?: string;
}

Step 3: The Type-Safe Client

Now, let's build the actual function. We will wrap the native fetch API in a typed function. This acts as our client, handling the networking and ensuring type safety at the boundary.


typescript
const API_BASE_URL = 'https