Solar Arc Directions

Endpoint POST https://starsapi.com/api/v3/western/forecasting/solar-arc

Overview

Computes solar arc directions. The Sun’s progressed movement (roughly 1° per year) is applied uniformly to all natal planets, advancing them by the same arc. Returns directed positions for every planet and all aspects between directed planets and natal positions.

Solar arc directions are a popular timing technique — simpler than secondary progressions (which move each planet at its own rate) but highly effective for pinpointing major life events.

Authentication

Method	Example
Header (recommended)	`X-Api-Key: am_live_xxxxxxxxxxxx`
Bearer	`Authorization: Bearer am_live_xxxxxxxxxxxx`

Request body

Field	Type	Required	Description
`year` – `minute`		Yes	Standard birth data fields.
`latitude`, `longitude`	number	Yes	Birth location.
`timezone`	string	Yes	IANA timezone.
`house_system`	string	No	Default `placidus`.
`node_type`	string	No	Default `true`.
`target_year`	integer	Yes	Target year.
`target_month`	integer	Yes	Target month.
`target_day`	integer	Yes	Target day.

Response shape

Field	Description
`natal_planets`	Original natal positions.
`directed_planets`	Each planet advanced by the solar arc. Includes both directed and natal longitude/sign.
`directed_aspects`	Directed-to-natal aspects with orbs.
`solar_arc_degrees`	The arc in degrees (~1°/year).
`target_date`	The target date used.

Errors

HTTP	Code	Cause
400	`MISSING_FIELD`	Required field absent.
500	`EPHEMERIS_ERROR`	Computation failed.

# Replace YOUR_API_KEY with the key from your dashboard
curl -X POST "https://starsapi.com/api/v3/western/forecasting/solar-arc" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "year": 1990,
        "month": 5,
        "day": 20,
        "hour": 14,
        "minute": 30,
        "second": 0,
        "latitude": 28.6139,
        "longitude": 77.209,
        "timezone": "Asia/Kolkata",
        "house_system": "placidus",
        "node_type": "true",
        "target_year": 2026,
        "target_month": 6,
        "target_day": 17
    }'

const response = await fetch(
  'https://starsapi.com/api/v3/western/forecasting/solar-arc',
  {
    method: 'POST',
    headers: {
      'X-Api-Key': 'YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      year: 1990,
      month: 5,
      day: 20,
      hour: 14,
      minute: 30,
      second: 0,
      latitude: 28.6139,
      longitude: 77.209,
      timezone: 'Asia/Kolkata',
      house_system: 'placidus',
      node_type: 'true',
      target_year: 2026,
      target_month: 6,
      target_day: 17
    })
  }
);
const result = await response.json();

if (result.success) {
  console.log(result.data);
}

import requests
import os

response = requests.post(
    'https://starsapi.com/api/v3/western/forecasting/solar-arc',
    headers={'X-Api-Key': os.environ['STARSAPI_KEY']},
    json={
        'year': 1990,
        'month': 5,
        'day': 20,
        'hour': 14,
        'minute': 30,
        'second': 0,
        'latitude': 28.6139,
        'longitude': 77.209,
        'timezone': 'Asia/Kolkata',
        'house_system': 'placidus',
        'node_type': 'true',
        'target_year': 2026,
        'target_month': 6,
        'target_day': 17
    }
)
result = response.json()

if result['success']:
    print(result['data'])

<?php
$payload = [
    'year' => 1990,
    'month' => 5,
    'day' => 20,
    'hour' => 14,
    'minute' => 30,
    'second' => 0,
    'latitude' => 28.6139,
    'longitude' => 77.209,
    'timezone' => 'Asia/Kolkata',
    'house_system' => 'placidus',
    'node_type' => 'true',
    'target_year' => 2026,
    'target_month' => 6,
    'target_day' => 17,
];

$ch = curl_init('https://starsapi.com/api/v3/western/forecasting/solar-arc');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-Api-Key: ' . getenv('STARSAPI_KEY'),
    'Content-Type: application/json'
]);

$response = curl_exec($ch);
$data = json_decode($response, true);

if ($data['success']) {
    print_r($data['data']);
}

import 'package:http/http.dart' as http;
import 'dart:convert';

Future<Map<String, dynamic>> getAscendant() async {
  final response = await http.post(
    Uri.parse('https://starsapi.com/api/v3/western/forecasting/solar-arc'),
    headers: {
      'X-Api-Key': 'YOUR_API_KEY',
      'Content-Type': 'application/json',
    },
    body: jsonEncode({
      'year': 1990,
      'month': 5,
      'day': 20,
      'hour': 14,
      'minute': 30,
      'second': 0,
      'latitude': 28.6139,
      'longitude': 77.209,
      'timezone': 'Asia/Kolkata',
      'house_system': 'placidus',
      'node_type': 'true',
      'target_year': 2026,
      'target_month': 6,
      'target_day': 17,
    }),
  );
  return jsonDecode(response.body);
}

import Foundation

func getAscendant() async throws -> [String: Any] {
    var request = URLRequest(url: URL(string:
        "https://starsapi.com/api/v3/western/forecasting/solar-arc"
    )!)
    request.httpMethod = "POST"
    request.setValue("YOUR_API_KEY", forHTTPHeaderField: "X-Api-Key")
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = """
        {
            "year": 1990,
            "month": 5,
            "day": 20,
            "hour": 14,
            "minute": 30,
            "second": 0,
            "latitude": 28.6139,
            "longitude": 77.209,
            "timezone": "Asia/Kolkata",
            "house_system": "placidus",
            "node_type": "true",
            "target_year": 2026,
            "target_month": 6,
            "target_day": 17
        }
        """.data(using: .utf8)

    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONSerialization.jsonObject(with: data) as! [String: Any]
}

import okhttp3.*
import org.json.JSONObject

val client = OkHttpClient()
val JSON = "application/json; charset=utf-8".toMediaType()

fun getAscendant(callback: (JSONObject) -> Unit) {
    val payload = """
    {
        "year": 1990,
        "month": 5,
        "day": 20,
        "hour": 14,
        "minute": 30,
        "second": 0,
        "latitude": 28.6139,
        "longitude": 77.209,
        "timezone": "Asia/Kolkata",
        "house_system": "placidus",
        "node_type": "true",
        "target_year": 2026,
        "target_month": 6,
        "target_day": 17
    }
    """.trimIndent()

    val request = Request.Builder()
        .url("https://starsapi.com/api/v3/western/forecasting/solar-arc")
        .addHeader("X-Api-Key", "YOUR_API_KEY")
        .post(payload.toRequestBody(JSON))
        .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            callback(JSONObject(response.body!!.string()))
        }
        override fun onFailure(call: Call, e: java.io.IOException) {
            e.printStackTrace()
        }
    })
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

func main() {
    payload, _ := json.Marshal(map[string]interface{}{
        "year": 1990,
        "month": 5,
        "day": 20,
        "hour": 14,
        "minute": 30,
        "second": 0,
        "latitude": 28.6139,
        "longitude": 77.209,
        "timezone": "Asia/Kolkata",
        "house_system": "placidus",
        "node_type": "true",
        "target_year": 2026,
        "target_month": 6,
        "target_day": 17,
    })

    req, _ := http.NewRequest("POST",
        "https://starsapi.com/api/v3/western/forecasting/solar-arc",
        bytes.NewBuffer(payload))
    req.Header.Set("X-Api-Key", os.Getenv("STARSAPI_KEY"))
    req.Header.Set("Content-Type", "application/json")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result["data"])
}

require 'net/http'
require 'json'

uri = URI('https://starsapi.com/api/v3/western/forecasting/solar-arc')
payload = {
  'year' => 1990,
  'month' => 5,
  'day' => 20,
  'hour' => 14,
  'minute' => 30,
  'second' => 0,
  'latitude' => 28.6139,
  'longitude' => 77.209,
  'timezone' => 'Asia/Kolkata',
  'house_system' => 'placidus',
  'node_type' => 'true',
  'target_year' => 2026,
  'target_month' => 6,
  'target_day' => 17
}

req = Net::HTTP::Post.new(uri)
req['X-Api-Key'] = ENV['STARSAPI_KEY']
req['Content-Type'] = 'application/json'
req.body = payload.to_json

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
res = http.request(req)

data = JSON.parse(res.body)
puts data['data'] if data['success']

200 RESPONSE

{
  "status": 200,
  "success": true,
  "data": {
    "natal_planets": { "Sun": { "longitude": 59.09, "sign": "Taurus" } },
    "directed_planets": {
      "Sun": { "longitude": 95.24, "sign": "Cancer", "natal_longitude": 59.09, "natal_sign": "Taurus" },
      "Moon": { "longitude": 37.61, "sign": "Taurus", "natal_longitude": 1.47, "natal_sign": "Aries" }
    },
    "directed_aspects": [
      { "directed_planet": "Venus", "natal_planet": "Saturn", "aspect": "Conjunction", "orb": 0.82 }
    ],
    "solar_arc_degrees": 36.15,
    "target_date": "2026-06-17"
  },
  "meta": { "endpoint": "/api/v3/western/forecasting/solar-arc", "version": "3.0" }
}