What is a yoga in Vedic astrology?

A yoga is a specific planetary combination that classical Jyotish texts say produces a result. Raj Yoga points to status and power, Dhana Yoga to wealth, and Pancha Mahapurusha Yoga marks one of five strong, well-placed planets. There are hundreds of named yogas across texts like Brihat Parashara Hora Shastra and Phaladeepika. The Vedic Yogas API detects them from a birth chart and returns each one as structured JSON with the planets involved, the rule that was met, a strength score, and a classical citation.

How do I detect Raj Yoga programmatically?

Send a POST to /api/v3/vedic/yoga-analysis with the subject's birth_data and include raj_yoga in include_categories, or leave categories open to run all families. The API casts the sidereal chart, checks the lord and house relationships that form Raj Yoga, and returns each match with planets_involved, houses_involved, and a condition_met sentence. Each hit also carries a 0-100 strength score, a Bhanga cancellation check, and a citation, so you can show users exactly why the yoga applies instead of just printing 'you have Raj Yoga'.

What is the endpoint and request shape?

The endpoint is POST /api/v3/vedic/yoga-analysis. The body takes subject (birth_data: name, date, time, location), an optional include_categories array to scope which yoga families run, an optional strict_mode boolean, and options where you set the ayanamsa such as lahiri. If you omit include_categories, the API runs all 11 families plus the arishta, dosha, and modifier engines. The response is flat JSON with an array of detected yoga objects, each fully described. The endpoint rejects unknown fields so payload typos come back as a clear error.

What does each detected yoga return?

Every yoga is a full object: name and sanskrit_name in IAST transliteration, category, planets_involved, houses_involved, and condition_met as a readable sentence. It also returns strength from 0 to 100, a strength_breakdown showing each factor, is_cancelled with cancellation_strength and bhanga_factors, provenance (classical, modern, or contested), a citation like 'Phaladeepika 6.34', a controversy_note, the variant, the nature (benefic, malefic, mixed, or conditional), and effects split into positive and challenges arrays. That is enough to build a screen that explains each reading and links to the source.

Which yoga families does the API support?

Eleven families: pancha_mahapurusha, chandra_yoga, surya_yoga, raj_yoga, dhana_yoga, viparita_yoga, nabhasa_yoga, sannyasa_yoga, profession_yoga, relationship_yoga, and longevity_yoga, plus travel and sudden-event families. On top of those sit neecha_bhanga (the debilitation-cancellation raja yoga), an arishta family for affliction yogas like Balarishta and Kala Sarpa, a dosha family for afflictions, and modifier yogas like Shubha and Papa Kartari. The unified Bhanga engine then checks every detected yoga for cancellation. You scope which families run with the include_categories array.

What is Neecha Bhanga Raja Yoga and how is it detected?

Neecha Bhanga Raja Yoga is the case where a debilitated planet's debilitation is itself cancelled, which flips a weakness into a power yoga. Detecting it by hand means tracking several cancellation conditions across the chart, which is why many apps miss it. The API exposes it as its own neecha_bhanga category, so it appears explicitly in the response with its cancellation_strength and the bhanga_factors that triggered the flip. You do not have to infer it from a debilitated planet plus a separate cancellation flag; it comes back as a named yoga.

What does provenance mean and why does it matter?

Provenance tags each yoga as classical, modern, or contested. Classical means the rule comes straight from a foundational text. Modern means a later or 20th-century addition. Contested means astrologers disagree on the exact conditions or the effect. This matters because a black-box API states modern opinion as fact. With the provenance field plus a controversy_note, your app can mark a contested yoga with a small note instead of presenting one school's view as universal truth. That keeps your product honest and protects you from users who know the texts.

Why are citations included with each yoga?

Each yoga returns a citation such as 'Phaladeepika 6.34' or 'BPHS Ch. 79', the classical source for that rule. Citations let you build a UI that says 'Source: Phaladeepika 6.34' under a reading, which is exactly what working astrologers and serious students expect. It also makes your app auditable: a user or an astrologer can check the rule against the text. No other yoga API ships the source, so this is the single biggest trust feature for a professional Jyotish product.

strict_mode is a boolean in the request. Classical texts sometimes disagree on the exact conditions for a yoga or a cancellation. With strict_mode off, the engine uses the more inclusive reading. With strict_mode on, it applies the stricter classical variant, so a yoga only fires when the tighter conditions are met, and a cancellation only counts under the stricter rule. Use strict_mode on for professional or research products where false positives are costly, and off for consumer apps where you want to surface more potential yogas.

How does the strength score work?

Each yoga returns a strength from 0 to 100 plus a strength_breakdown that shows how each factor contributed, such as planetary dignity, house placement, and aspects. This solves a common problem: a textbook-perfect Gajakesari and a barely-qualifying one used to look identical in the JSON. With a score you can rank yogas, hide weak ones below a threshold, draw a meter in the UI, and explain to a user why one yoga is stronger than another. The breakdown is what lets you justify the number instead of presenting it as magic.

Which ayanamsa can I use?

You set the ayanamsa in the options object, for example options.ayanamsa = 'lahiri'. Lahiri is the default most Indian astrologers use, and it is what the yoga rules were validated against. Because yoga detection depends on sidereal sign and house placement, the ayanamsa you pick can change which yogas fire near a sign boundary, so set it deliberately and keep it consistent across your app. If you also use our Vedic Astrology API for the underlying chart, use the same ayanamsa in both calls so the results line up.

A full-chart analysis that runs all 11 families averages under 400ms. If you scope the run with include_categories to just one or two families, it is faster. That speed means you can call it inline when a user opens their chart instead of precomputing yogas overnight. Measurements are p50 from production traffic. Compare that to the 1 to 3 second responses common from generic Vedic APIs, or a self-hosted rule engine that has to load an ephemeris on every call.

How many languages are supported?

The interpretation copy ships in 14 languages across 107 interpretation keys, added in the 2026-05-28 release. The structural fields like sanskrit_name, citation, and condition_met stay consistent, while the positive effects and challenges text come back in the language you request. That means you can launch a yoga screen in Hindi, English, Spanish, and more without writing or maintaining the interpretation copy yourself. Sanskrit names always use IAST transliteration regardless of the interface language.

How do I authenticate?

Standard Bearer token in the Authorization header. Sign up, copy your key from the dashboard, and send it as 'Authorization: Bearer YOUR_KEY' on every request. The same key works across all endpoints, so once you are set up for yoga analysis you also have access to the other 100+ calculations including the full Vedic chart. Keys are scoped per environment, and you can rotate them anytime. There is no OAuth flow and no SDK required; curl works fine for testing.

How much does it cost?

Free tier: $0/month with 50 requests. Starter: $11/month for 1,000 requests. Professional: $37/month for 55,000 requests, the most popular plan. Business: $99/month for 220,000 requests. Enterprise: $399+/month with unlimited usage and dedicated servers. Every plan includes the full yoga endpoint with all 11 families, the Bhanga engine, citations, and 14 languages; nothing is gated by tier. There is a 30-day money-back guarantee on paid plans, no setup fees, and no per-call surcharges.

Can I run yoga detection across many charts?

Yes. The endpoint is per-subject, so each chart is one POST. For batch or research workloads, send them in parallel; paid plans do not throttle at the per-second level. The strength score and provenance fields are built for this kind of analysis, letting you filter a dataset to classical, uncancelled yogas above a strength threshold. If you need true async batch ingestion for a large research project, ask sales about enterprise batch endpoints. For a consumer app, most teams cache each user's yoga result and only re-run when the birth data changes.

Why use this instead of building yoga detection myself?

Encoding yoga rules by hand takes a realistic 8 to 16 weeks for one engineer, and most in-house builds stall on the cancellation logic because the exceptions are scattered across BPHS, Phaladeepika, and Saravali and often contradict each other. You also have to write interpretation copy in every language you ship. The API gives you all 11 families, the unified Bhanga engine, citations, strength scoring, provenance, and 14 languages behind one Bearer-token POST, with Swiss Ephemeris precision underneath. You spend the saved months on the part users actually see.

How accurate is the detection?

Planetary positions use Swiss Ephemeris with 1-arcsecond precision, and the chart is cast in the sidereal zodiac with your chosen ayanamsa. The yoga rules are encoded from classical sources and carry their citation, so each detection is traceable to a text. The Bhanga engine applies the standard cancellation rules, and strict_mode switches to the tighter classical variant where texts disagree. If you spot a result that conflicts with a published example, send it to support with the chart and the source; every report is investigated and tracked in a changelog.

Vedic Yogas API

Vedic Yoga Detection API With Citations

Detect Raj Yoga, Dhana Yoga, Pancha Mahapurusha, Viparita, Neecha Bhanga and 11 yoga families in one POST.

Every result ships with a classical citation, a 0-100 strength score, and a Bhanga cancellation check. 14 languages, Swiss Ephemeris precision, under 400ms.

View Documentation

<400ms

Average Response

Yoga Families

Languages

0-100

Strength Scores

Every yoga cites its classical source

Used by 2,847+ developers

99.9% uptime SLA

Solve it with

Performance Built for Production

Real numbers from real traffic, not marketing slides

<400ms

Average Response

Yoga Families

107

Interpretation Keys

Languages

What is the Vedic Yogas API?

Citation-backed yoga detection for Jyotish app developers

A yoga in Vedic astrology is a specific planetary combination that classical texts say produces a result. Raj Yoga points to status and power. Dhana Yoga points to wealth. Pancha Mahapurusha Yoga marks a strong, well-placed planet. The Vedic Yogas API detects these combinations from a birth chart and returns them as structured JSON. The difference from other APIs is what comes back with each hit: the Sanskrit name, the planets and houses involved, the exact rule that was met, a 0-100 strength score, a cancellation check, and a classical citation like 'Phaladeepika 6.34'. Shipped on 2026-05-28, the latest release added 11 yoga families, a unified Bhanga (cancellation) engine, and interpretations in 14 languages across 107 interpretation keys. Send one POST to /api/v3/vedic/yoga-analysis and you get an explainable result instead of a verdict you have to trust blindly.

How does the Vedic Yogas API detect a yoga?

You POST a subject with birth_data: name, date, time, and location.

The API casts the sidereal chart using Swiss Ephemeris and your chosen ayanamsa, such as Lahiri.

Then it runs the chart against each yoga family you ask for.

You scope the run with include_categories so you can request only raj_yoga and dhana_yoga, or leave it open to run all 11 families.

For each combination that matches, the rule engine records which planets and houses triggered it and writes that into condition_met as plain text.

The strict_mode flag switches to the stricter classical variant of a rule when texts disagree on the exact conditions.

The whole run finishes in under 400 milliseconds for a full-chart analysis, so you can call it inline when a user opens their chart rather than precomputing overnight.

One POST runs all 11 yoga families in under 400ms

1 min read

What makes the output audit-grade?

Every detected yoga is a full object, not a label.

It carries name and sanskrit_name in IAST transliteration, the category it belongs to, planets_involved, houses_involved, and condition_met as a human-readable sentence.

It carries a strength score from 0 to 100 plus a strength_breakdown that shows how each factor added up, so a weak yoga and a textbook one never look the same.

It carries is_cancelled, cancellation_strength, and bhanga_factors that list which cancellation rules fired.

It carries provenance (classical, modern, or contested), a citation such as 'BPHS Ch.

79', a controversy_note, the variant, the nature (benefic, malefic, mixed, or conditional), and effects split into positive and challenges arrays.

That structure means you can build a UI that explains each reading, link to the source text, and let a user audit why the app said what it said.

Strength, cancellation, citation, and provenance on every result

1 min read

Which yoga families does the API cover?

The API covers 11 families plus the supporting engines.

Pancha Mahapurusha (Ruchaka, Bhadra, Hamsa, Malavya, Shasha) flags the five great-person yogas.

Raj Yoga covers status and authority combinations, and Dhana Yoga covers wealth.

Viparita Raja Yoga covers success that comes through reversal or hardship.

Chandra and Surya yogas anchor off the Moon and Sun.

Nabhasa yogas cover the geometric pattern combinations.

Sannyasa yogas point to renunciation and spiritual life.

There are also profession, relationship, longevity, travel, and sudden-event families, an arishta family for affliction yogas like Balarishta and Kala Sarpa, a dosha family for afflictions, and modifier yogas like Shubha and Papa Kartari.

On top of that sits neecha_bhanga, the debilitation-cancellation raja yoga, and the unified Bhanga engine that checks whether any detected yoga is cancelled.

11 yoga families plus arishta, dosha, and modifier engines

1 min read

What is the Bhanga cancellation engine?

Bhanga means cancellation.

A planet can sit in a yoga-forming spot but be debilitated, combust, or otherwise compromised, in which case the classical texts say the yoga does not deliver, or delivers only after a reversal.

Most APIs ignore this and report the raw combination, which produces wrong readings.

The unified Bhanga engine checks every detected yoga against the standard cancellation rules and returns is_cancelled as a boolean, a cancellation_strength score, and bhanga_factors that name each rule that contributed.

The most famous case is Neecha Bhanga Raja Yoga, where a debilitated planet's debilitation is itself cancelled, flipping a weakness into a power yoga.

The API exposes that as its own neecha_bhanga category so you can detect the flip explicitly instead of inferring it.

With strict_mode on, the engine applies the stricter classical reading of when a cancellation actually counts.

is_cancelled, cancellation_strength, and per-rule bhanga_factors

1 min read

How do I show users why a yoga applies?

This is the part that opaque APIs cannot do.

Because each result ships planets_involved, houses_involved, and condition_met, you can render a sentence like 'Hamsa Yoga: Jupiter in Cancer in the 1st house, in its own exaltation.' Because each result ships a citation, you can add 'Source: Phaladeepika 6.4' under it.

Because each result ships strength and strength_breakdown, you can draw a meter and explain the factors.

Because each result ships provenance and controversy_note, you can mark a contested yoga with a small note so you are not stating one school's opinion as universal fact.

The 14-language interpretation keys give you the prewritten positive effects and challenges in the user's language.

The net result is a yoga screen a working astrologer would trust, not a horoscope-style black box.

Explainable readings, not 'trust me' verdicts

1 min read

How does it compare to building yoga detection yourself?

Encoding yoga rules by hand is a long project.

You license an ephemeris, implement sidereal math with ayanamsa selection, then read Brihat Parashara Hora Shastra, Phaladeepika, Saravali, and Jataka Parijata to extract hundreds of rules.

Then you encode the cancellation logic, which is where most in-house projects stall, because the exceptions are scattered across texts and often contradict each other.

Then you write interpretation copy in every language you ship.

A realistic estimate is 8 to 16 weeks for one engineer, and the result is usually missing cancellation and provenance.

The API gives you all 11 families, the Bhanga engine, citations, strength scoring, and 14 languages behind a Bearer-token POST.

Swiss Ephemeris underneath means 1-arcsecond planetary precision.

You spend the saved months on the part users see, which is how the yoga reads in your app.

Ship yoga detection in a day, not a quarter

1 min read

Use Cases

Jyotish and Kundli Apps

Add a yoga screen that lists Raj, Dhana, and Mahapurusha yogas with strength meters and the rule behind each one. Cancellation is handled, so the readings hold up.

AI Astrology Chatbots

Feed detected yogas, their condition_met text, and citations into the prompt so the model talks about real combinations with sources instead of generic predictions.

Professional Astrologer SaaS

Give working astrologers an audit-grade yoga report with citations and Bhanga factors they can verify against the classical texts before they counsel a client.

Marriage and Matchmaking Platforms

Use relationship and longevity yogas plus dosha and arishta checks to add depth beyond a simple guna score, with provenance flags on contested rules.

Education and Learning Platforms

Teach yoga detection with live charts. Each result shows the citation and the strength_breakdown, so students see exactly which factors made the yoga strong.

Research and Data Platforms

Run yoga detection across large chart datasets. The strength score and provenance fields let you filter to classical, uncancelled yogas above a threshold.

Technical Specifications

Endpoint	POST /api/v3/vedic/yoga-analysis
Average Response Time	<400ms full-chart analysis
Ephemeris	Swiss Ephemeris, 1-arcsecond precision
Yoga Families	11 plus arishta, dosha, neecha_bhanga, and modifier engines
Cancellation	Unified Bhanga engine with is_cancelled and bhanga_factors
Strength Scoring	0-100 per yoga with strength_breakdown
Provenance	classical, modern, or contested, plus controversy_note
Citations	Classical source per yoga, e.g. Phaladeepika 6.34, BPHS Ch. 79
Sanskrit Names	IAST transliteration in sanskrit_name
Ayanamsa	Selectable in options, e.g. lahiri
Categories Filter	include_categories to scope which families run
Strict Mode	strict_mode toggles stricter classical variant readings
Interpretations	14 languages across 107 interpretation keys
Response Format	Flat JSON, no XML, no SOAP
Auth	Bearer token, standard HTTP

Vedic Yogas API vs. the Alternatives

Feature	Astrology API	Others
Why a yoga applies	planets, houses, and condition_met text	Just a label, no rule shown
Cancellation	Bhanga engine with per-rule factors	Ignored, raw combinations only
Strength scoring	0-100 with strength_breakdown	Present or absent, no ranking
Provenance	classical, modern, or contested flag	All mixed, no distinction
Citations	Classical source per yoga	None
Neecha Bhanga	Its own detected category	Inferred or missing
Languages	14 languages, 107 keys	English only, often none
Price	$11/mo starter, $37 most popular	$29-499/mo or self-host

Related Vedic APIs

Vedic Astrology API

Kundli, Shadbala, and vargas D1-D60 that feed yoga detection

Vimshottari Dasha API

Planetary periods that time when a yoga activates

Nakshatra API

Lunar mansions and padas used across Vedic readings

Divisional Charts API

Varga charts that several yoga rules depend on

Navamsa Calculator API

The D9 chart that strengthens or weakens a yoga

Birth Chart (Vedic) API

Full sidereal chart the yoga engine runs against

References & Standards

Swiss Ephemeris (DE431-based) — astronomical calculations source
NASA JPL Planetary Ephemerides — underlying ephemeris dataset
International Astronomical Union (IAU) — body designation and nomenclature standards
IANA Time Zone Database — timezone & DST resolution

Full Vedic Yogas Feature Set

Every yoga family and engine exposed as JSON

Pancha Mahapurusha Yogas

Ruchaka, Bhadra, Hamsa, Malavya, and Shasha, the five great-person yogas

Detected with planet, house, dignity, and strength score

Raj Yoga Detection

Status and authority combinations from lord and house relationships

Returns planets_involved, condition_met, and a citation

Dhana Yoga (Wealth)

Wealth combinations from the 2nd, 5th, 9th, and 11th lord links

Each hit carries strength_breakdown and cancellation check

Viparita Raja Yoga

Success that arrives through reversal or hardship

Harsha, Sarala, and Vimala variants flagged with nature

Neecha Bhanga Raja Yoga

A debilitated planet whose debilitation is cancelled, flipping weakness to power

Its own category with cancellation_strength and bhanga_factors

Unified Bhanga Engine

Checks every detected yoga for cancellation across the standard rules

Returns is_cancelled, cancellation_strength, and per-rule factors

Chandra and Surya Yogas

Moon-anchored and Sun-anchored yogas like Gajakesari and Vasi

Scoped via include_categories chandra_yoga and surya_yoga

Nabhasa Pattern Yogas

Geometric pattern yogas based on how planets group across signs

Pattern, variant, and nature returned per detection

Sannyasa (Spiritual) Yogas

Renunciation and spiritual-life combinations

Tagged with provenance and effects arrays

Profession, Relationship, Longevity, Travel

Topical families for career, partnership, lifespan, and journeys

Run together or scoped with include_categories

Arishta and Dosha Families

Affliction yogas like Balarishta and Kala Sarpa, plus dosha checks

Nature marked malefic or conditional with challenges listed

Strength, Provenance, and Citations

Every result carries a 0-100 score, a classical, modern, or contested tag, and a source

name, sanskrit_name (IAST), citation, controversy_note, variant

Vedic Yogas API Comparison - Why We're Better

See how we stack up against the alternatives

Feature	Astrology API	Generic Vedic APIs	Open-Source Libs	DIY Build
Why a yoga appliesExplainable on every result	planets, houses, condition_met text	Label only	Raw combination	You write it
Cancellation (Bhanga)is_cancelled with bhanga_factors	Unified engine, per-rule factors	Ignored	Partial	Hardest part to encode
Strength scoringSort and filter with one field	0-100 with breakdown	None	None	Build it yourself
Citations and provenanceAudit-grade output	Source + classical/modern/contested	None	None	Read the texts yourself
LanguagesLocalized interpretations	14 languages, 107 keys	English only	None	Write all copy
Response TimeInline, not overnight	<400ms	1-3 seconds	Local, varies	Varies
Pricing4-5x cheaper than generic APIs	$11-399/mo	$29-499/mo	Free + maintenance	8-16 weeks of dev

Best Choice

Why a yoga applies

Explainable on every result

Astrology API

planets, houses, condition_met text

Generic Vedic APIs

Label only

Open-Source Libs

Raw combination

DIY Build

You write it

Best Choice

Cancellation (Bhanga)

is_cancelled with bhanga_factors

Astrology API

Unified engine, per-rule factors

Generic Vedic APIs

Ignored

Open-Source Libs

Partial

DIY Build

Hardest part to encode

Best Choice

Strength scoring

Sort and filter with one field

Astrology API

0-100 with breakdown

Generic Vedic APIs

None

Open-Source Libs

None

DIY Build

Build it yourself

Best Choice

Citations and provenance

Audit-grade output

Astrology API

Source + classical/modern/contested

Generic Vedic APIs

None

Open-Source Libs

None

DIY Build

Read the texts yourself

Best Choice

Languages

Localized interpretations

Astrology API

14 languages, 107 keys

Generic Vedic APIs

English only

Open-Source Libs

None

DIY Build

Write all copy

Best Choice

Response Time

Inline, not overnight

Astrology API

<400ms

Generic Vedic APIs

1-3 seconds

Open-Source Libs

Local, varies

DIY Build

Varies

Best Choice

Pricing

4-5x cheaper than generic APIs

Astrology API

$11-399/mo

Generic Vedic APIs

$29-499/mo

Open-Source Libs

Free + maintenance

DIY Build

8-16 weeks of dev

Vedic Yogas API Questions

What developers ask before integrating yoga detection

Simple, Transparent Pricing

Start free, scale as you grow. No hidden fees, no surprises.

Always Free

Start Free

Perfect for learning, testing, and small personal projects

50 API calls/month

Basic natal charts

5 house systems

Community support

Pro

$11/month

For small apps and personal projects

All basic endpoints
12 house systems
Email support

Best Value

Pro Plus

$21/month

For growing apps and medium traffic

All enhanced endpoints
18 house systems
AI interpretations
Priority email support

Ultra

$37/month

For professional astrology applications

Credit math ↓

All premium endpoints
23 house systems
Advanced AI interpretations
Priority support

High Volume Plans

For enterprise-scale applications

Business

$99/month

For high-volume applications

Credit math ↓

ALL endpoints
White-label ready
Custom AI fine-tuning
Phone support

UNLIMITED

Enterprise

$399+per month

Unlimited requests with dedicated infrastructure

Dedicated server infrastructure
Sub-300ms guaranteed
24/7 dedicated support
99.99% uptime SLA

All plans include comprehensive documentation and SDKs

Questions? Talk to our team

Complete Your Vedic Stack

Yoga detection pairs naturally with the rest of the Vedic toolkit. Add

Vedic Astrology APIthe Kundli, Shadbala, and vargas that feed yoga rules Vimshottari Dasha APIthe periods that time when a yoga activates Nakshatra APIthe lunar mansions used across Vedic readings Divisional Charts APIthe varga charts several yoga rules depend on Navamsa Calculator APIthe D9 chart that strengthens or weakens a yoga Birth Chart (Vedic) APIthe full sidereal chart the engine runs against

Citation-Backed Yoga Detection, One POST Away

Ship Yoga Detection

All 11 yoga families, a unified Bhanga cancellation engine, 0-100 strength scores, classical citations, and 14 languages. Under 400ms. Free tier covers 50 calls a month so you can prototype before you commit.

Get API Key Read the Docs

50 free requests a month, every month. Test the full yoga endpoint before deciding.

Vedic Yoga Detection API With Citations

Why Most Yoga APIs Are Black Boxes

The Vedic Yogas API Solution

Performance Built for Production

What is the Vedic Yogas API?

How does the Vedic Yogas API detect a yoga?

What makes the output audit-grade?

Which yoga families does the API cover?

What is the Bhanga cancellation engine?

How do I show users why a yoga applies?

How does it compare to building yoga detection yourself?

Use Cases

Jyotish and Kundli Apps

AI Astrology Chatbots

Professional Astrologer SaaS

Marriage and Matchmaking Platforms

Education and Learning Platforms

Research and Data Platforms

Technical Specifications

Vedic Yogas API vs. the Alternatives

Related Vedic APIs

Vedic Astrology API

Vimshottari Dasha API

Nakshatra API

Divisional Charts API

Navamsa Calculator API

Birth Chart (Vedic) API

References & Standards

Full Vedic Yogas Feature Set

Pancha Mahapurusha Yogas

Raj Yoga Detection

Dhana Yoga (Wealth)

Viparita Raja Yoga

Neecha Bhanga Raja Yoga

Unified Bhanga Engine

Chandra and Surya Yogas

Nabhasa Pattern Yogas

Sannyasa (Spiritual) Yogas

Profession, Relationship, Longevity, Travel

Arishta and Dosha Families

Strength, Provenance, and Citations

Vedic Yogas API Comparison - Why We're Better

Why a yoga applies

Cancellation (Bhanga)

Strength scoring

Citations and provenance

Languages

Response Time

Pricing

Vedic Yogas API Questions

What is a yoga in Vedic astrology?

How do I detect Raj Yoga programmatically?

What is the endpoint and request shape?

What does each detected yoga return?

Which yoga families does the API support?

What is the Bhanga cancellation engine?

What is Neecha Bhanga Raja Yoga and how is it detected?

What does provenance mean and why does it matter?

Why are citations included with each yoga?

What is strict_mode?

How does the strength score work?

Which ayanamsa can I use?

How fast is the API?

How many languages are supported?

How do I authenticate?

How much does it cost?

Can I run yoga detection across many charts?

Why use this instead of building yoga detection myself?

How accurate is the detection?

Simple, Transparent Pricing

Always Free

Pro

Pro Plus

Ultra

High Volume Plans

Business

Enterprise

Complete Your Vedic Stack

Ship Yoga Detection

Why Most Yoga APIs Are Black Boxes