Rectification API: Birth Time Correction for Developers

Most astrology users know their birth date, but not the exact time. A 30-minute difference can change the ascendant by 5+ degrees, shifting house placements and aspects. For serious astrology work, this matters.

The astrologer’s technique for fixing this is rectification — using known life events to back-calculate the likely birth time. Traditionally it takes hours of manual work. AstroWay exposes two algorithmic rectification endpoints that automate it.

This post is about when to use rectification, how the algorithms work, and how to integrate it into your app.

Rectification is birth time correction. You start with an approximate time (e.g. “morning” or “around 14:00”) and narrow it down using:

• Major life events (marriage, children, career changes, deaths)
• Physical characteristics (classical astrology maps ascendant signs to body types)
• Angular positions of planets at birth

The output is a refined birth time, usually within ±5 minutes of the true value.

A classical method attributed to Hermes Trismegistus. It uses the relationship between the Moon’s position at birth and the ascendant/descendant at conception (~9 months earlier).

The method:

1. Takes the native’s birth date (approximate)
2. Calculates the conception date range (260–290 days earlier)
3. For each candidate conception date, checks if the birth Moon’s position corresponds to the ascendant/descendant at conception
4. Returns candidate birth times ranked by fit

Fast but less precise. Good for narrowing a wide window (e.g. “morning” → 2-hour window).

const result = await client.rectificationTrutine({
  date: '1990-07-14',
  timeRange: { start: '06:00:00', end: '12:00:00' },
  latitude: 50.4501,
  longitude: 30.5234,
  timezoneOffset: 3,
});

console.log(`Best candidate: ${result.bestTime}`);
console.log(`Confidence: ${result.confidence}`);

Algorithmic approach using multiple life events. This is the heavyweight option (up to 120s per request).

Inputs:

• Approximate birth time (a range)
• List of life events with dates and types
• Optional: physical description

The algorithm:

1. Generates candidate birth times within the range (typically 1-minute resolution)
2. For each candidate, calculates the natal chart
3. Scores each candidate by how well the events match predicted astrological patterns (progressions, directions, transits)
4. Returns the top candidates with confidence scores

const result = await client.rectification({
  date: '1990-07-14',
  timeRange: { start: '06:00:00', end: '18:00:00' },
  latitude: 50.4501,
  longitude: 30.5234,
  timezoneOffset: 3,
  events: [
    { date: '2015-06-20', type: 'marriage' },
    { date: '2018-03-12', type: 'firstChild' },
    { date: '2020-09-05', type: 'careerChange' },
  ],
});

console.log(`Rectified time: ${result.bestTime}`);
console.log(`Candidates: ${result.candidates.length}`);

Rectification is valuable for:

• Apps with “unknown time” users — auto-offer rectification as a premium feature
• Professional astrologer tools — save hours of manual work per client
• HD apps — Human Design is very sensitive to time; rectification dramatically improves accuracy
• Research apps — validate historical charts where time records are imprecise

It’s not useful for:

• Apps where users already know their time within ±5 minutes (no benefit)
• Casual horoscope apps where time precision doesn’t affect output (daily sun sign doesn’t need this)

• Trutine: 250 credits — runs in ~1–2 seconds
• Full rectification: 500 credits — runs in up to 120 seconds

These are the heaviest endpoints in the API. If you’re offering rectification as a feature, charge accordingly — it’s a premium operation that justifies a higher-tier subscription or one-time purchase.

For budget planning:

• 100 rectifications per month: ~50,000 credits = Pro plan ($59) with room for other calls
• 1,000 rectifications per month: 500,000 credits = Enterprise

Rectification takes time. Your UI needs:

• Async handling — don’t block on the request; queue it, show progress
• Progress indicator — the full endpoint runs up to 120s; users need feedback
• Result presentation — show the refined time, confidence level, and let users regenerate if events are uncertain

async function handleRectify(input: RectifyInput) {
  setLoading(true);
  setStatus('Running rectification (this may take up to 2 minutes)...');

  try {
    const result = await client.rectification(input);
    setResult(result);
    setStatus(`Done. Refined time: ${result.bestTime} (confidence ${result.confidence}%)`);
  } catch (err) {
    setStatus(`Error: ${err.message}`);
  } finally {
    setLoading(false);
  }
}

A typical rectification flow in an app:

1. User enters approximate birth data + life events
2. App calls /v1/rectification/trutine first (cheap, fast) to narrow the window
3. App calls /v1/rectification (full) with the narrowed window for precision
4. App caches the result and uses the refined time for all future calculations
5. App flags future calls with the refined time + a note “rectified from approximate”

This combined approach is ~750 credits per full rectification flow but gives the best accuracy.

Rectification is never 100% accurate. Even professional astrologers disagree on best-fit times by 5–10 minutes.

AstroWay’s algorithm is designed for relative accuracy — it narrows the window, but the output is always a “best candidate”, not a certainty. Always show users the confidence score and let them override if they have better information.

Algorithms are pattern-matching. A skilled astrologer considers context that’s hard to encode: “Was the marriage rushed?” “Was the career change voluntary?” For high-stakes charts, combine:

1. Algorithmic rectification to narrow the window
2. Manual review by astrologer for the final refinement

Your app can offer this as a premium consultation upsell.

• API reference — find rectification and rectification/trutine endpoints
• Pricing — credit costs per plan
• Quick start — get your API key