DEV Community: AstroAsk

How to Build a Natal Chart App with Free Western Astrology API — Aspects, Houses & Synastry

AstroAsk — Thu, 04 Jun 2026 12:10:59 +0000

Natal chart with aspects, house systems, chart patterns, synastry, and SVG wheel rendering — one API call, 75ms.

The Problem
Meet AstroAsk API
What We're Building
Step 1: Get Your Free API Key
Step 2: Your First Natal Chart API Call
Step 3: Understanding the Response
Step 4: Aspects — The Hidden Language of Charts
Step 5: House Systems Explained
Step 6: Chart Patterns (Grand Trine, T-Square, Yod)
Step 7: Synastry — Relationship Compatibility
Step 8: Solar Return — Your Year Ahead
Step 9: Display the Chart Wheel (SVG)
Real-World Use Cases
Gotchas & Tips
What to Build Next

The Problem

You're building a Western astrology app. Users want:

Natal chart (birth chart) with all 10 planets
Aspects between planets (conjunction, trine, square, etc.)
House systems (Placidus, Koch, Equal, Whole Sign)
Synastry (relationship compatibility)
Solar return (birthday chart for the year ahead)
A visual chart wheel they can share

You search for a Western astrology API and find:

APIs that only do Vedic astrology
APIs that need 10+ separate calls for one complete chart
APIs that charge per-endpoint (one call for planets, another for houses, another for aspects...)
APIs with no SVG rendering — you have to build your own chart wheel
APIs that cost $37-850/month before you even test

What if one API returned everything in a single call?

Meet AstroAsk — Free Western Astrology API

AstroAsk is a free API built specifically for developers adding astrology to their apps.

Why developers love it:

✅ Complete natal chart in one API call
✅ 10 planets + 12 houses + all major aspects
✅ Multiple house systems (Placidus, Koch, Equal, Whole Sign, more)
✅ Chart pattern detection (Grand Trine, Grand Cross, T-Square, Yod, Stellium)
✅ Synastry for relationship compatibility
✅ Solar return charts
✅ Secondary progressions & solar arc directions
✅ Planetary transits to natal chart
✅ SVG chart wheel rendering (ready to display)
✅ Auto-timezone from coordinates (no UTC conversion!)
✅ 75ms average latency
✅ Free tier: 500 requests/month
✅ NASA JPL-precision calculations

What We're Building

A complete Western astrology feature that:

Takes birth details (date, time, place)
Returns natal chart with planets, houses, and aspects
Detects chart patterns (Grand Trine, T-Square, Yod)
Calculates synastry between two people
Generates solar return for any year
Renders as a beautiful SVG chart wheel

Time to build: 10 minutes

Step 1: Get Your Free API Key

Go to AstroAsk on RapidAPI
Click "Subscribe to Test"
Select the Basic (Free) plan
Copy your API key from the dashboard

No credit card needed.

Step 2: Your First Natal Chart API Call

Let's get a Western natal chart for someone born on November 11, 2002 at midnight in New York.

Python

import requests

url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/western"

payload = {
    "date": "2002-11-11T00:00:00",
    "lat": 40.7128,   # New York latitude
    "lng": -74.0060,  # New York longitude
    "houseSystem": "placidus",
    "format": "json"
}

headers = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "astroask-vedic-western-astrology-api.p.rapidapi.com",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(data)

JavaScript (Node.js)

const url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/western";

const payload = {
    date: "2002-11-11T00:00:00",
    lat: 40.7128,
    lng: -74.0060,
    houseSystem: "placidus",
    format: "json"
};

const response = await fetch(url, {
    method: "POST",
    headers: {
        "x-rapidapi-key": "YOUR_API_KEY",
        "x-rapidapi-host": "astroask-vedic-western-astrology-api.p.rapidapi.com",
        "Content-Type": "application/json"
    },
    body: JSON.stringify(payload)
});

const data = await response.json();
console.log(data);

cURL

curl -X POST "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/western" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: astroask-vedic-western-astrology-api.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"date": "2002-11-11T00:00:00", "lat": 40.7128, "lng": -74.0060, "houseSystem": "placidus"}'

Step 3: Understanding the Natal Chart Response

Here's what you get back:

{
  "success": true,
  "data": {
    "planets": [
      {
        "planet": "Sun",
        "signName": "Scorpio",
        "tropicalLongitude": 228.19,
        "house": 3,
        "isRetrograde": false
      },
      {
        "planet": "Moon",
        "signName": "Aquarius",
        "tropicalLongitude": 305.41,
        "house": 6,
        "isRetrograde": false
      },
      {
        "planet": "Mercury",
        "signName": "Scorpio",
        "tropicalLongitude": 215.87,
        "house": 3,
        "isRetrograde": false
      }
      // ... all 10 planets (Sun through Pluto)
    ],
    "houses": {
      "houses": [
        {"house": 1, "sign": "Libra", "cusp": 195.52},
        {"house": 2, "sign": "Scorpio", "cusp": 225.31}
        // ... all 12 houses
      ],
      "ascendant": {"sign": "Libra", "degree": 15.52},
      "midheaven": {"sign": "Cancer", "degree": 78.23}
    },
    "aspects": [
      {
        "planet1": "Sun",
        "planet2": "Moon",
        "aspect": "Square",
        "angle": 82.78,
        "orb": 7.22,
        "isApplying": true
      },
      {
        "planet1": "Venus",
        "planet2": "Mars",
        "aspect": "Trine",
        "angle": 119.45,
        "orb": 0.55,
        "isApplying": false
      }
      // ... all major aspects
    ],
    "patterns": [
      {
        "type": "Stellium",
        "planets": ["Sun", "Mercury", "Venus"],
        "sign": "Scorpio",
        "description": "3 planets in Scorpio — intense focus on transformation"
      }
    ]
  }
}

Key Western fields:

Field	What it means
`planets`	All 10 planets with tropical zodiac positions
`houses`	12 house cusps with signs (Placidus system)
`aspects`	Angles between planets (conjunction, trine, square, etc.)
`patterns`	Detected chart shapes (Grand Trine, T-Square, Yod, Stellium)
`ascendant`	Rising sign — your public persona
`midheaven`	Career and reputation point

Step 4: Aspects — The Hidden Language of Charts

Aspects are the angles between planets. They reveal how planetary energies interact.

The Major Aspects:

Aspect	Angle	Symbol	Meaning
Conjunction	0°	☌	Energies merge — intense focus
Sextile	60°	⚹	Easy flow — opportunities
Square	90°	□	Tension — growth through challenge
Trine	120°	△	Harmony — natural talent
Opposition	180°	☍	Polarity — awareness through contrast

The Minor Aspects:

Aspect	Angle	Meaning
Semi-sextile	30°	Subtle connection
Quincunx	150°	Adjustment needed
Semi-square	45°	Mild friction
Sesquiquadrate	135°	Inner tension

Using aspects in your app:

def get_chart_aspects(birth_data):
    """Get all aspects in a natal chart."""
    chart = get_natal_chart(birth_data)
    aspects = chart['aspects']

    # Filter for major aspects only
    major_aspects = [a for a in aspects if a['aspect'] in 
        ['Conjunction', 'Trine', 'Square', 'Sextile', 'Opposition']]

    # Sort by orb (tightest aspects first — most powerful)
    major_aspects.sort(key=lambda a: a['orb'])

    return {
        "total_aspects": len(aspects),
        "major_aspects": major_aspects,
        "tightest_aspect": major_aspects[0] if major_aspects else None
    }

Why orb matters:

The "orb" is how far off the exact angle the aspect is. Tighter orb = stronger influence.

0-2°: Very strong — dominant influence
2-5°: Strong — clearly felt
5-8°: Moderate — noticeable
8-10°: Weak — background influence

Step 5: House Systems Explained

Houses divide the chart into 12 life areas. Different house systems calculate house cusps differently.

Supported house systems:

System	Best for	How it works
Placidus	Most popular	Time-based division (default)
Koch	German tradition	Birth time sensitive
Equal	Simple	Each house = 30°
Whole Sign	Modern revival	Each sign = one house
Campanus	Space-based	Prime vertical division
Regiomontanus	Medieval	Celestial equator based

Switching house systems:

# Default — Placidus
payload = {"date": "2002-11-11T00:00:00", "lat": 40.7128, "lng": -74.0060}

# Explicit house system
payload = {
    "date": "2002-11-11T00:00:00",
    "lat": 40.7128,
    "lng": -74.0060,
    "houseSystem": "whole_sign"  # Options: placidus, koch, equal, whole_sign, campanus, regiomontanus
}

The 12 Houses:

House	Life Area	Keywords
1st	Self	Identity, appearance, first impressions
2nd	Values	Money, possessions, self-worth
3rd	Communication	Siblings, short travel, learning
4th	Home	Family, roots, private life
5th	Creativity	Romance, children, hobbies
6th	Health	Daily routine, work, service
7th	Partnerships	Marriage, open enemies, contracts
8th	Transformation	Death, taxes, shared resources
9th	Philosophy	Higher education, travel, beliefs
10th	Career	Reputation, authority, public image
11th	Community	Friends, hopes, social causes
12th	Subconscious	Secrets, isolation, spiritual growth

Step 6: Chart Patterns (Grand Trine, T-Square, Yod)

The API automatically detects major chart patterns. These are rare configurations that shape personality.

Supported patterns:

Pattern	Shape	Meaning
Grand Trine	△△△ (3 trines)	Natural talent — things come easy
Grand Cross	□□□□ (4 squares)	Intense challenges — builds resilience
T-Square	□△ (2 squares + opposition)	Driven tension — motivates achievement
Yod	⚹⚹△ (2 sextiles + quincunx)	"Finger of God" — special mission
Stellium	3+ planets in one sign	Intense focus in one life area

Detecting patterns:

def analyze_chart_patterns(birth_data):
    """Detect major chart patterns in a natal chart."""
    chart = get_natal_chart(birth_data)
    patterns = chart['patterns']

    result = {
        "has_grand_trine": any(p['type'] == 'Grand Trine' for p in patterns),
        "has_t_square": any(p['type'] == 'T-Square' for p in patterns),
        "has_yod": any(p['type'] == 'Yod' for p in patterns),
        "has_stellium": any(p['type'] == 'Stellium' for p in patterns),
        "pattern_count": len(patterns),
        "patterns": patterns
    }

    if result['has_grand_trine']:
        result['advice'] = "You have natural gifts — focus on developing them"
    elif result['has_t_square']:
        result['advice'] = "Your challenges drive your greatest growth"

    return result

You can also detect specific patterns individually:

# For detailed pattern analysis, use the patterns endpoint
url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/western/patterns"

payload = {"date": "2002-11-11T00:00:00"}

response = requests.post(url, json=payload, headers=headers)
patterns = response.json()

# Returns: grandTrines, grandCrosses, tSquares, yods, stelliums
print(f"Grand Trines: {patterns['data']['summary']['grandTrineCount']}")
print(f"T-Squares: {patterns['data']['summary']['tSquareCount']}")

Step 7: Synastry — Relationship Compatibility

Synastry compares two birth charts to reveal relationship dynamics. Different from Vedic Gun Milan — this is the Western approach.

API call for synastry:

url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/compatibility"

payload = {
    "person1": {
        "date": "2002-11-11T00:00:00",
        "lat": 40.7128,
        "lng": -74.0060
    },
    "person2": {
        "date": "1999-05-15T14:30:00",
        "lat": 34.0522,
        "lng": -118.2437
    },
    "system": "western"  # Key: use "western" for tropical synastry
}

response = requests.post(url, json=payload, headers=headers)
synastry = response.json()

print(synastry)

What synastry reveals:

def get_relationship_report(person1_data, person2_data):
    """Generate a Western synastry compatibility report."""
    synastry = get_synastry(person1_data, person2_data, system="western")

    # Find the strongest aspects between charts
    interaspects = synastry['data']['interaspects']

    # Categorize by type
    harmonious = [a for a in interaspects if a['aspect'] in ['Trine', 'Sextile', 'Conjunction']]
    challenging = [a for a in interaspects if a['aspect'] in ['Square', 'Opposition']]

    return {
        "harmonious_connections": len(harmonious),
        "challenging_connections": len(challenging),
        "strongest_aspect": min(interaspects, key=lambda a: a['orb']),
        "summary": generate_summary(harmonious, challenging)
    }

Key synastry aspects to look for:

Cross-Aspect	Meaning
Sun-Moon conjunction	Core compatibility — emotional understanding
Venus-Mars conjunction	Romantic chemistry — strong attraction
Moon-Moon trine	Emotional flow — feel at home together
Sun-Saturn square	Growth through friction — builds commitment
Venus-Venus trine	Shared values — easy affection

Step 8: Solar Return — Your Year Ahead

A solar return chart is cast for the exact moment the Sun returns to its natal position each year. It reveals themes for the year ahead.

url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/western/solar-return"

payload = {
    "date": "2002-11-11T00:00:00",  # Birth date
    "lat": 40.7128,
    "lng": -74.0060,
    "targetYear": 2026  # Which year to calculate
}

response = requests.post(url, json=payload, headers=headers)
solar_return = response.json()

print(f"Solar Return 2026 themes:")
print(f"  Ascendant: {solar_return['data']['ascendant']['sign']}")
print(f"  Sun house: {solar_return['data']['sunHouse']}")
print(f"  Moon sign: {solar_return['data']['moonSign']}")

Why solar returns matter:

The solar return Ascendant shows the "face" of your year
The house the Sun falls in shows the year's focus area
Aspects in the solar return show the year's opportunities and challenges

Step 9: Display the Chart Wheel (SVG)

The API can return a beautiful SVG chart wheel ready to display. No chart-building code needed.

# Get the chart as SVG
payload = {
    "date": "2002-11-11T00:00:00",
    "lat": 40.7128,
    "lng": -74.0060,
    "format": "svg",           # Return SVG instead of JSON
    "theme": "dark",           # "light" or "dark"
    "showTable": true,         # Show planet positions table
    "width": 800,
    "height": 800,
    "wheelSize": 600,
    "rotateToAscendant": true, # Ascendant at 9 o'clock
    "planetRenderMode": "glyph",  # "glyph" (symbols) or "text"
    "signRenderMode": "glyph"     # "glyph" (symbols) or "text"
}

response = requests.post(url, json=payload, headers=headers)
svg_data = response.json()

# Save the SVG
with open("natal_chart.svg", "w") as f:
    f.write(svg_data['data']['svg'])

HTML

<div id="natal-chart"></div>

<script>
// After fetching the API response
const chartSvg = data.data.svg;
document.getElementById('natal-chart').innerHTML = chartSvg;
</script>

React

function NatalChart({ birthData }) {
  const [chartSvg, setChartSvg] = useState('');

  useEffect(() => {
    fetch('/api/western', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ ...birthData, format: 'svg', theme: 'dark' })
    })
    .then(res => res.json())
    .then(data => setChartSvg(data.data.svg));
  }, [birthData]);

  return (
    <div 
      className="natal-chart-container"
      dangerouslySetInnerHTML={{ __html: chartSvg }} 
    />
  );
}

SVG customization options:

Option	Values	Default
`theme`	`light`, `dark`	`light`
`showTable`	`true`, `false`	`false`
`width`	pixels	`800`
`height`	pixels	`800`
`wheelSize`	pixels	`600`
`layout`	`row`, `column`	`row`
`planetRenderMode`	`glyph`, `text`	`glyph`
`signRenderMode`	`glyph`, `text`	`glyph`
`fillZodiacElements`	`true`, `false`	`false`

Real-World Use Cases

1. Astrology Dating App

@app.route('/api/compatibility-check')
def compatibility_check():
    """Check synastry between two users."""
    synastry = get_synastry(
        user1.birth_data, 
        user2.birth_data, 
        system="western"
    )

    interaspects = synastry['data']['interaspects']

    # Calculate compatibility score
    harmonious = len([a for a in interaspects if a['aspect'] in ['Trine', 'Sextile']])
    challenging = len([a for a in interaspects if a['aspect'] in ['Square', 'Opposition']])

    score = min(100, max(0, 50 + (harmonious * 10) - (challenging * 5)))

    return {
        "compatibility_score": score,
        "harmonious_aspects": harmonious,
        "challenging_aspects": challenging,
        "strongest_connection": min(interaspects, key=lambda a: a['orb']),
        "summary": generate_synastry_summary(interaspects)
    }

2. Daily Horoscope Generator

@app.route('/api/daily-horoscope')
def daily_horoscope():
    """Generate personalized daily horoscope using transits."""
    # Get current transits to user's natal chart
    transits = get_transits(user.birth_data, target_date=today)

    # Find active transits (tight orbs)
    active_transits = [t for t in transits if t['orb'] < 3]

    prompt = f"""
    User's natal chart: {user.birth_chart}
    Active transits today: {active_transits}

    Write a personalized daily horoscope based on these transits.
    Be specific about which planetary aspects are active.
    """

    return {"horoscope": ai_generate(prompt)}

3. Year-Ahead Report

@app.route('/api/year-ahead')
def year_ahead():
    """Generate solar return + progressions report."""
    solar_return = get_solar_return(user.birth_data, target_year=2026)
    progressions = get_progressions(user.birth_data, target_date=today)

    return {
        "solar_return": {
            "themes": solar_return['data']['themes'],
            "focus_area": solar_return['data']['sunHouse'],
            "opportunities": solar_return['data']['aspects']
        },
        "progressions": {
            "progressed_moon_sign": progressions['data']['progressedMoonSign'],
            "solar_arc_aspects": progressions['data']['solarArcAspects']
        },
        "advice": generate_year_advice(solar_return, progressions)
    }

4. Embeddable Chart Widget

// Embed natal chart in any website
function embedChart(containerId, birthData, options = {}) {
  const defaultOptions = {
    format: 'svg',
    theme: 'dark',
    width: 500,
    height: 500,
    wheelSize: 400,
    showTable: true,
    rotateToAscendant: true
  };

  const payload = { ...birthData, ...defaultOptions, ...options };

  fetch('https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/western', {
    method: 'POST',
    headers: {
      'x-rapidapi-key': 'YOUR_API_KEY',
      'x-rapidapi-host': 'astroask-vedic-western-astrology-api.p.rapidapi.com',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  })
  .then(res => res.json())
  .then(data => {
    document.getElementById(containerId).innerHTML = data.data.svg;
  });
}

// Usage
embedChart('my-chart', {
  date: '2002-11-11T00:00:00',
  lat: 40.7128,
  lng: -74.0060
}, { theme: 'dark', width: 600 });

Gotchas & Tips

1. Timezone Handling

Don't convert to UTC! The API auto-derives timezone from coordinates.

# ✅ CORRECT — use local birth time
{"date": "2002-11-11T14:30:00", "lat": 40.7128, "lng": -74.0060}

# ❌ WRONG — don't convert to UTC yourself
{"date": "2002-11-11T19:30:00Z", "lat": 40.7128, "lng": -74.0060}

2. Tropical vs Sidereal Zodiac

AstroAsk Western API uses tropical zodiac (Western standard). If you need sidereal (Vedic), use the /api/v1/kundali endpoint instead.

# Western — tropical zodiac (Aries starts at vernal equinox)
response = requests.post(".../api/v1/western", ...)

# Vedic — sidereal zodiac (accounts for precession)
response = requests.post(".../api/v1/kundali", ...)

3. House System Selection

Different astrologers prefer different house systems. Let users choose:

HOUSE_SYSTEMS = {
    "placidus": "Most popular (default)",
    "koch": "German school",
    "equal": "Simple 30° houses",
    "whole_sign": "Modern revival — each sign = one house",
    "campanus": "Space-based division",
    "regiomontanus": "Medieval tradition"
}

4. Coordinate Accuracy

For accurate house cusps, use precise coordinates:

# ❌ WRONG — city center approximation
{"lat": 40.7, "lng": -74.0}

# ✅ CORRECT — precise coordinates
{"lat": 40.7128, "lng": -74.0060}

House cusps are sensitive to location. A 0.1° difference in coordinates can shift house boundaries.

5. Rate Limiting

Free tier: 500 requests/month. Cache results!

from functools import lru_cache

@lru_cache(maxsize=1000)
def get_natal_chart(date, lat, lng):
    # Only calls API once per unique birth data
    return api_call(date, lat, lng)

6. Aspect Orbs

The API returns aspects with their orb (distance from exact angle). Filter for tight orbs for strongest influences:

# Get only strong aspects (orb < 5°)
strong_aspects = [a for a in aspects if a['orb'] < 5]

7. Error Handling

Always check for errors:

response = requests.post(url, json=payload, headers=headers)
data = response.json()

if not data.get('success'):
    error = data.get('error', 'Unknown error')
    print(f"API Error: {error}")
    return None

What to Build Next

Now that you have the basics, here are ideas:

Astrology Dating App — Synastry-based matching
Daily Horoscope Newsletter — Transits to natal chart
Birth Chart Generator — Shareable SVG chart wheels
Year-Ahead Reports — Solar return + progressions
Compatibility Calculator — Relationship analysis widget
Astrology Chatbot — AI-powered chart interpretation
Transit Tracker — "What's affecting you today"
Chart Pattern Finder — "Do you have a Grand Trine?"

Links & Resources

🔗 AstroAsk on RapidAPI — Subscribe (free)
📖 API Documentation — Full endpoint reference
🐦 Twitter/X — Updates and astrology tips
🐛 Report Issues — Found a bug? Let us know

Conclusion

Building a Western astrology app doesn't have to be hard. With AstroAsk:

One API call gets you planets, houses, aspects, and patterns
SVG rendering means no chart-wheel building code
Multiple house systems serve all astrologer preferences
Synastry powers dating and compatibility apps
Free tier lets you test without commitment
75ms latency keeps your app fast

Try it today. Your users will thank you.

Have questions? Drop a comment below or email us at intelligence@astroask.app

About the Author
Building AstroAsk — making astrology accessible to developers. NASA JPL-precision calculations, tropical + sidereal zodiac, one API.

How to Build a Kundali App with Free Vedic Astrology API — Step by Step

AstroAsk — Sat, 30 May 2026 21:20:32 +0000

Complete Vedic birth chart (Kundali) with nakshatras, dashas, and gun milan — one API call, 75ms.

The Problem
Meet AstroAsk API
What We're Building
Step 1: Get Your Free API Key
Step 2: Your First Kundali API Call
Step 3: Understanding the Response
Step 4: Display the Chart
Step 5: Nakshatras Explained
Step 6: Dasha System
Step 7: Gun Milan (Compatibility)
Real-World Use Cases
Gotchas & Tips
What to Build Next

The Problem

You're building an astrology app for Indian users. They want:

Kundali (birth chart) with all 9 planets
Nakshatras (lunar mansions)
Dasha periods (planetary timing)
Gun Milan (compatibility matching)
Charts in Hindi, Tamil, Telugu, or their language

You search for a Vedic astrology API and find:

APIs that only do Western astrology
APIs that need 6-10 calls for one chart
APIs with 500ms+ latency
APIs that cost ₹4000/month before testing
APIs that don't support Indian languages

What if one API did everything?

Meet AstroAsk — Free Vedic Astrology API

AstroAsk is a free API built specifically for developers adding Vedic astrology to their apps.

Why developers love it:

✅ Complete Kundali in one API call
✅ 9 planets + 12 houses + 27 nakshatras
✅ Dasha system (Mahadasha, Antardasha)
✅ Gun Milan for compatibility (36-point system)
✅ SVG chart rendering (ready to display)
✅ 21 languages (Hindi, Tamil, Telugu, Bengali, more)
✅ Auto-timezone from coordinates (no UTC conversion!)
✅ 75ms average latency (10x faster than alternatives)
✅ Free tier: 500 requests/month
✅ NASA JPL-precision calculations

What We're Building

A simple Kundali feature that:

Takes birth details (date, time, place)
Returns complete Vedic birth chart
Shows nakshatras and dashas
Renders as an SVG chart image
Works in Hindi or English

Time to build: 10 minutes

Step 1: Get Your Free API Key

Go to AstroAsk on RapidAPI
Click "Subscribe to Test"
Select the Basic (Free) plan
Copy your API key from the dashboard

No credit card needed.

Step 2: Your First Kundali API Call

Let's get a Vedic birth chart for someone born on November 11, 2002 at midnight in New Delhi.

Python

import requests

url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/kundali"

payload = {
    "date": "2002-11-11T00:00:00",
    "lat": 28.6139,  # New Delhi latitude
    "lng": 77.2090,  # New Delhi longitude
    "lang": "hi"     # Hindi output
}

headers = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "astroask-vedic-western-astrology-api.p.rapidapi.com",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)
data = response.json()

print(data)

JavaScript (Node.js)

const url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/kundali";

const payload = {
    date: "2002-11-11T00:00:00",
    lat: 28.6139,
    lng: 77.2090,
    lang: "hi"
};

const response = await fetch(url, {
    method: "POST",
    headers: {
        "x-rapidapi-key": "YOUR_API_KEY",
        "x-rapidapi-host": "astroask-vedic-western-astrology-api.p.rapidapi.com",
        "Content-Type": "application/json"
    },
    body: JSON.stringify(payload)
});

const data = await response.json();
console.log(data);

cURL

curl -X POST "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/kundali" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: astroask-vedic-western-astrology-api.p.rapidapi.com" \
  -H "Content-Type: application/json" \
  -d '{"date": "2002-11-11T00:00:00", "lat": 28.6139, "lng": 77.2090, "lang": "hi"}'

Step 3: Understanding the Kundali Response

Here's what you get back:

{
  "success": true,
  "data": {
    "birth_chart": {
      "ascendant": {
        "sign": "कर्क",        // Cancer in Hindi
        "degree": 12.45,
        "nakshatra": "पुष्य"   // Pushya nakshatra
      },
      "planets": [
        {
          "name": "सूर्य",      // Sun
          "sign": "तुला",      // Libra
          "degree": 24.32,
          "house": 4,
          "nakshatra": "विशाखा", // Vishakha
          "retrograde": false
        },
        {
          "name": "चंद्र",      // Moon
          "sign": "वृषभ",      // Taurus
          "degree": 8.67,
          "house": 11,
          "nakshatra": "कृत्तिका", // Krittika
          "retrograde": false
        }
        // ... all 9 Vedic planets
      ],
      "houses": [
        {"number": 1, "sign": "कर्क", "lord": "चंद्र"},
        {"number": 2, "sign": "सिंह", "lord": "सूर्य"}
        // ... all 12 houses
      ]
    },
    "chart_svg": "<svg>...</svg>",
    "dashas": {
      "current_mahadasha": "राहु",    // Rahu
      "current_antardasha": "गुरु",   // Jupiter
      "period": "2020-2038"
    },
    "nakshatras": {
      "moon_nakshatra": "कृत्तिका",
      "pada": 2,
      "rashi": "वृषभ"
    }
  }
}

Key Vedic fields:

birth_chart — All 9 planets with signs, degrees, houses
nakshatras — Lunar mansions (27 nakshatras, 4 padas each)
dashas — Current planetary period (Mahadasha + Antardasha)
chart_svg — Ready-to-display SVG chart image

Step 4: Display the Kundali Chart

The API returns an SVG image. Just embed it:

HTML

<div id="kundali-chart"></div>

<script>
// After fetching the API response
const chartSvg = data.data.chart_svg;
document.getElementById('kundali-chart').innerHTML = chartSvg;
</script>

React

function KundaliChart({ birthData }) {
  const [chartSvg, setChartSvg] = useState('');

  useEffect(() => {
    fetch('/api/kundali', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(birthData)
    })
    .then(res => res.json())
    .then(data => setChartSvg(data.data.chart_svg));
  }, [birthData]);

  return (
    <div 
      className="kundali-container"
      dangerouslySetInnerHTML={{ __html: chartSvg }} 
    />
  );
}

That's it. No need to build a chart renderer. The SVG is ready to display.

Step 5: Nakshatras Explained

Nakshatras are lunar mansions — unique to Vedic astrology. Each person has a birth nakshatra based on Moon's position.

Why nakshatras matter:

Determines personality traits
Used for naming babies (first letter based on nakshatra)
Critical for marriage matching (kundali milan)
Predicts life events and timing

The 27 Nakshatras:

#	Nakshatra	Ruling Planet	Symbol
1	Ashwini	Ketu	Horse head
2	Bharani	Venus	Yoni
3	Krittika	Sun	Razor
4	Rohini	Moon	Chariot
5	Mrigashira	Mars	Deer head
...	...	...	...

Using nakshatras in your app:

def get_nakshatra_info(birth_data):
    chart = get_kundali(birth_data)
    moon_nakshatra = chart['nakshatras']['moon_nakshatra']
    pada = chart['nakshatras']['pada']

    return {
        "nakshatra": moon_nakshatra,
        "pada": pada,
        "first_letter": get_nakshatra_letter(moon_nakshatra, pada)
    }

Step 6: Dasha System (Planetary Timing)

Dashas are Vedic astrology's timing system. They predict which planet influences your life during different periods.

The Vimshottari Dasha system:

Total cycle: 120 years
Each planet rules for a specific period
Current Mahadasha = major life theme
Current Antardasha = sub-period influence

Planet Dasha periods:

Planet	Years
Ketu	7
Venus	20
Sun	6
Moon	10
Mars	7
Rahu	18
Jupiter	16
Saturn	19
Mercury	17

Using dashas in your app:

def get_current_dasha(birth_data):
    chart = get_kundali(birth_data)
    dashas = chart['dashas']

    return {
        "mahadasha": dashas['current_mahadasha'],
        "antardasha": dashas['current_antardasha'],
        "period": dashas['period'],
        "description": get_dasha_effects(
            dashas['current_mahadasha'],
            dashas['current_antardasha']
        )
    }

Step 7: Gun Milan (Compatibility Matching)

For matrimonial apps, Gun Milan is essential. It's a 36-point compatibility system.

The 8 Gunas (Koots):

#	.Guna	Points	What it measures
1	Varna	4	Spiritual compatibility
2	Vashya	2	Mutual attraction
3	Tara	3	Health & well-being
4	Yoni	4	Nature & temperament
5	Graha Maitri	5	Planetary friendship
6	Gana	6	Behavior & attitude
7	Bhakoot	7	Health & happiness
8	Nadi	8	Genetic compatibility

Total: 36 points

Scoring:

18+ points: Acceptable match
25+ points: Good match
30+ points: Excellent match

API call for Gun Milan:

url = "https://astroask-vedic-western-astrology-api.p.rapidapi.com/api/v1/compatibility"

payload = {
    "person1": {
        "date": "2002-11-11T00:00:00",
        "lat": 28.6139,
        "lng": 77.2090
    },
    "person2": {
        "date": "1999-05-15T14:30:00",
        "lat": 19.0760,
        "lng": 72.8777
    },
    "system": "vedic"
}

response = requests.post(url, json=payload, headers=headers)
compatibility = response.json()

print(f"Total Score: {compatibility['data']['total_score']}/36")
print(f"Recommendation: {compatibility['data']['recommendation']}")

Real-World Use Cases

1. Matrimonial App

@app.route('/api/match-compatibility')
def match_compatibility():
    result = get_gun_milan(boy.birth_data, girl.birth_data)

    return {
        "total_score": result['total_score'],
        "max_score": 36,
        "gunas": result['gunas'],  # Individual scores
        "recommendation": result['recommendation'],
        "is_compatible": result['total_score'] >= 18
    }

2. Kundali Generation Service

@app.route('/api/generate-kundali')
def generate_kundali():
    chart = get_kundali(user.birth_data)

    return {
        "planets": chart['birth_chart']['planets'],
        "houses": chart['birth_chart']['houses'],
        "nakshatras": chart['nakshatras'],
        "dashas": chart['dashas'],
        "chart_image": chart['chart_svg'],
        "language": user.preferred_language
    }

3. Baby Naming App

@app.route('/api/baby-name-suggestions')
def baby_names():
    # Get birth nakshatra
    chart = get_kundali(baby.birth_data)
    nakshatra = chart['nakshatras']['moon_nakshatra']
    pada = chart['nakshatras']['pada']

    # Get starting letter based on nakshatra
    first_letter = get_nakshatra_letter(nakshatra, pada)

    # Suggest names starting with that letter
    names = get_names_starting_with(first_letter, user.language)

    return {
        "nakshatra": nakshatra,
        "pada": pada,
        "starting_letter": first_letter,
        "suggested_names": names
    }

4. Astrology Chatbot

def handle_message(user_message, user_birth_data):
    # Get user's kundali
    chart = get_kundali(user_birth_data)

    # Use chart context in AI prompt
    prompt = f"""
    User's Kundali:
    - Nakshatra: {chart['nakshatras']['moon_nakshatra']}
    - Current Dasha: {chart['dashas']['current_mahadasha']}
    - Ascendant: {chart['birth_chart']['ascendant']['sign']}

    User's question: {user_message}

    Provide personalized Vedic astrology advice based on their chart.
    """

    return ai_generate(prompt)

Gotchas & Tips

1. Timezone Handling

Don't convert to UTC! The API auto-derives timezone from coordinates.

# ✅ CORRECT — use local birth time
{"date": "2002-11-11T14:30:00", "lat": 28.6139, "lng": 77.2090}

# ❌ WRONG — don't convert to UTC yourself
{"date": "2002-11-11T09:00:00Z", "lat": 28.6139, "lng": 77.2090}

2. Language Support

Pass lang parameter for localized output:

{"lang": "hi"}  # Hindi
{"lang": "ta"}  # Tamil
{"lang": "te"}  # Telugu
{"lang": "bn"}  # Bengali
{"lang": "mr"}  # Marathi
{"lang": "gu"}  # Gujarati
{"lang": "kn"}  # Kannada
{"lang": "ml"}  # Malayalam
{"lang": "pa"}  # Punjabi
{"lang": "en"}  # English

21 languages supported total.

3. Coordinate Accuracy

For accurate charts, use precise coordinates:

# ❌ WRONG — city center approximation
{"lat": 28.6, "lng": 77.2}

# ✅ CORRECT — precise coordinates
{"lat": 28.6139, "lng": 77.2090}

Use Google Maps or a geocoding API to get exact coordinates.

4. Rate Limiting

Free tier: 500 requests/month. Cache results!

from functools import lru_cache

@lru_cache(maxsize=1000)
def get_kundali(date, lat, lng):
    # Only calls API once per unique birth data
    return api_call(date, lat, lng)

5. Error Handling

Always check for errors:

response = requests.post(url, json=payload, headers=headers)
data = response.json()

if not data.get('success'):
    error = data.get('error', 'Unknown error')
    print(f"API Error: {error}")
    return None

What to Build Next

Now that you have the basics, here are ideas:

Matrimonial Matching — Gun Milan for arranged marriages
Kundali PDF Generator — Downloadable birth charts
Baby Naming App — Names based on nakshatra
Daily Panchang — Tithi, nakshatra, muhurta
Astrology Consultation Platform — Connect users with astrologers
Horoscope Newsletter — Personalized daily predictions
Kundali Matching Widget — Embeddable for wedding websites

Links & Resources

🔗 AstroAsk on RapidAPI — Subscribe (free)
📖 API Documentation — Full endpoint reference
💻 GitHub Examples — Python, JS, Flutter code
🐛 Report Issues — Found a bug? Let us know

Conclusion

Building a Kundali app doesn't have to be hard. With AstroAsk:

One API call gets you a complete Vedic birth chart
SVG rendering means no chart-building code
21 languages serves all Indian users
Free tier lets you test without commitment
75ms latency keeps your app fast

Try it today. Your users will thank you.

Have questions? Drop a comment below or email us at intelligence@astroask.app

About the Author
Building AstroAsk — making Vedic astrology accessible to developers. NASA JPL-precision calculations, 21 languages, one API.

DEV Community: AstroAsk

How to Build a Natal Chart App with Free Western Astrology API — Aspects, Houses & Synastry

Table of Contents

The Problem

Meet AstroAsk — Free Western Astrology API

What We're Building

Step 1: Get Your Free API Key

Step 2: Your First Natal Chart API Call

Python

JavaScript (Node.js)

cURL

Step 3: Understanding the Natal Chart Response

Step 4: Aspects — The Hidden Language of Charts

Step 5: House Systems Explained

Step 6: Chart Patterns (Grand Trine, T-Square, Yod)

Step 7: Synastry — Relationship Compatibility

Step 8: Solar Return — Your Year Ahead

Step 9: Display the Chart Wheel (SVG)

HTML

React

Real-World Use Cases

1. Astrology Dating App

2. Daily Horoscope Generator

3. Year-Ahead Report

4. Embeddable Chart Widget

Gotchas & Tips

1. Timezone Handling

2. Tropical vs Sidereal Zodiac

3. House System Selection

4. Coordinate Accuracy

5. Rate Limiting

6. Aspect Orbs

7. Error Handling

What to Build Next

Links & Resources

Conclusion

How to Build a Kundali App with Free Vedic Astrology API — Step by Step

Table of Contents

The Problem

Meet AstroAsk — Free Vedic Astrology API

What We're Building

Step 1: Get Your Free API Key

Step 2: Your First Kundali API Call

Python

JavaScript (Node.js)

cURL

Step 3: Understanding the Kundali Response

Step 4: Display the Kundali Chart

HTML

React

Step 5: Nakshatras Explained

Step 6: Dasha System (Planetary Timing)

Step 7: Gun Milan (Compatibility Matching)

Real-World Use Cases

1. Matrimonial App

2. Kundali Generation Service

3. Baby Naming App

4. Astrology Chatbot

Gotchas & Tips

1. Timezone Handling

2. Language Support

3. Coordinate Accuracy

4. Rate Limiting

5. Error Handling

What to Build Next

Links & Resources

Conclusion