An AI chat astrologer for one chart, or two.

# Step 1 — open a single-chart session
curl -X POST https://starsapi.com/api/v2/partner/ai/chat/start \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "astrologer":  "guruji",
    "year": 1990, "month": 6, "day": 15,
    "hour": 14,   "minute": 30,
    "timezone": "Asia/Kolkata",
    "latitude":   28.6139, "longitude": 77.2090,
    "name":  "Ravi",
    "gender":"male",
    "preferred_language":   "en"
  }'

# Response contains data.session_id and the opening greeting in
# data.new_messages[0].message (array of text chunks).

# Step 2 — every subsequent turn
curl -X POST https://starsapi.com/api/v2/partner/ai/chat/message \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "abc123def456abc123def456abc12345",
    "message":    "Will I get the promotion this year?"
  }'

const BASE    = "https://starsapi.com/api/v2/partner/ai/chat";
const headers = { "X-Api-Key": API_KEY, "Content-Type": "application/json" };

// Step 1 — open the session
const start = await fetch(`${BASE}/start`, {
  method:  "POST",
  headers,
  body: JSON.stringify({
    astrologer:  "guruji",
    year: 1990, month: 6, day: 15, hour: 14, minute: 30, timezone: "Asia/Kolkata",
    latitude: 28.6139, longitude: 77.2090,
    name: "Ravi", gender: "male",
    preferred_language: "en",
  }),
}).then(r => r.json());

const sessionId = start.data.session_id;
for (const chunk of start.data.new_messages[0].message) {
  renderBubble({ role: "astrologer", text: chunk });
}

// Step 2 — send a user message
async function sendMessage(text) {
  const r = await fetch(`${BASE}/message`, {
    method: "POST",
    headers,
    body: JSON.stringify({ session_id: sessionId, message: text }),
  }).then(r => r.json());

  for (const chunk of r.data.new_messages[0].message) {
    renderBubble({ role: "astrologer", text: chunk });
  }
  return r.data;
}

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

const BASE = 'https://starsapi.com/api/v2/partner/ai/chat';
final headers = {
  'X-Api-Key':    API_KEY,
  'Content-Type': 'application/json',
};

// Step 1 — open the session
final startResp = await http.post(
  Uri.parse('$BASE/start'),
  headers: headers,
  body: jsonEncode({
    'astrologer':  'guruji',
    'year': 1990, 'month': 6, 'day': 15,
    'hour': 14,   'minute': 30, 'timezone': 'Asia/Kolkata',
    'latitude':   28.6139, 'longitude': 77.2090,
    'name':  'Ravi',
    'gender':'male',
    'preferred_language':   'en',
  }),
);
final start = jsonDecode(startResp.body)['data'];
final sessionId = start['session_id'];
for (final chunk in start['new_messages'][0]['message']) {
  addBubble(role: 'astrologer', text: chunk);
}

// Step 2 — send a user message
Future<Map> sendMessage(String text) async {
  final r = await http.post(
    Uri.parse('$BASE/message'),
    headers: headers,
    body: jsonEncode({ 'session_id': sessionId, 'message': text }),
  );
  return jsonDecode(r.body)['data'];
}

import requests

BASE    = "https://starsapi.com/api/v2/partner/ai/chat"
HEADERS = { "X-Api-Key": API_KEY, "Content-Type": "application/json" }

# Step 1 — open the session
start = requests.post(f"{BASE}/start", headers=HEADERS, json={
    "astrologer":  "guruji",
    "year": 1990, "month": 6, "day": 15,
    "hour": 14,   "minute": 30, "timezone": "Asia/Kolkata",
    "latitude":   28.6139, "longitude": 77.2090,
    "name":  "Ravi",
    "gender":"male",
    "preferred_language":   "en",
}).json()

session_id = start["data"]["session_id"]
for chunk in start["data"]["new_messages"][0]["message"]:
    render_bubble(role="astrologer", text=chunk)

# Step 2 — every subsequent turn
def send_message(text: str) -> dict:
    r = requests.post(f"{BASE}/message", headers=HEADERS, json={
        "session_id": session_id,
        "message":    text,
    }).json()
    for chunk in r["data"]["new_messages"][0]["message"]:
        render_bubble(role="astrologer", text=chunk)
    return r["data"]

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import java.util.Map;

static final String BASE   = "https://starsapi.com/api/v2/partner/ai/chat";
static final HttpClient C  = HttpClient.newHttpClient();
static final ObjectMapper M = new ObjectMapper();

// Step 1 — open the session
String startBody = M.writeValueAsString(Map.of(
    "astrologer", "guruji",
    "year", 1990, "month", 6, "day", 15,
    "hour", 14,   "minute", 30, "timezone", 5.5,
    "latitude", 28.6139, "longitude", 77.2090,
    "name", "Ravi", "gender", "male",
    "preferred_language", "en"
));
HttpResponse<String> startResp = C.send(
    HttpRequest.newBuilder(URI.create(BASE + "/start"))
        .header("X-Api-Key",    API_KEY)
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(startBody)).build(),
    HttpResponse.BodyHandlers.ofString());
JsonNode start = M.readTree(startResp.body()).get("data");
String sessionId = start.get("session_id").asText();

// Step 2 — send a user message
String msgBody = M.writeValueAsString(Map.of(
    "session_id", sessionId,
    "message",    "Will I get the promotion this year?"
));
HttpResponse<String> msgResp = C.send(
    HttpRequest.newBuilder(URI.create(BASE + "/message"))
        .header("X-Api-Key",    API_KEY)
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(msgBody)).build(),
    HttpResponse.BodyHandlers.ofString());
JsonNode reply = M.readTree(msgResp.body()).get("data");
for (JsonNode chunk : reply.get("new_messages").get(0).get("message")) {
    System.out.println("Astrologer: " + chunk.asText());
}

package main

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

const base = "https://starsapi.com/api/v2/partner/ai/chat"

func post(path string, body any) (map[string]any, error) {
    b, _ := json.Marshal(body)
    req, _ := http.NewRequest("POST", base+path, bytes.NewReader(b))
    req.Header.Set("X-Api-Key",    apiKey)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var out map[string]any
    json.NewDecoder(resp.Body).Decode(&out)
    return out, nil
}

func main() {
    // Step 1 — open the session
    start, _ := post("/start", map[string]any{
        "astrologer":  "guruji",
        "year": 1990, "month": 6, "day": 15,
        "hour": 14, "minute": 30, "timezone": "Asia/Kolkata",
        "latitude": 28.6139, "longitude": 77.2090,
        "name": "Ravi", "gender": "male",
        "preferred_language": "en",
    })
    data := start["data"].(map[string]any)
    sessionId := data["session_id"].(string)
    for _, chunk := range data["new_messages"].([]any)[0].(map[string]any)["message"].([]any) {
        renderBubble("astrologer", chunk.(string))
    }

    // Step 2 — send a user message
    reply, _ := post("/message", map[string]any{
        "session_id": sessionId,
        "message":    "Will I get the promotion this year?",
    })
    _ = reply
}

// Requires cpprestsdk or libcurl + a JSON library (nlohmann/json).
// Example using cpprestsdk.

#include <cpprest/http_client.h>
#include <cpprest/json.h>
using namespace web;
using namespace web::http;
using namespace web::http::client;

const auto BASE = U("https://starsapi.com/api/v2/partner/ai/chat");

// Step 1 — open the session
http_client client(BASE);
json::value startBody;
startBody[U("astrologer")]   = json::value::string(U("guruji"));
startBody[U("year")]         = 1990;
startBody[U("month")]        = 6;
startBody[U("day")]          = 15;
startBody[U("hour")]         = 14;
startBody[U("minute")]       = 30;
startBody[U("timezone")]     = 5.5;
startBody[U("latitude")]     = 28.6139;
startBody[U("longitude")]    = 77.2090;
startBody[U("name")]    = json::value::string(U("Ravi"));
startBody[U("gender")]  = json::value::string(U("male"));
startBody[U("preferred_language")]     = json::value::string(U("en"));

http_request req(methods::POST);
req.set_request_uri(U("/start"));
req.headers().add(U("X-Api-Key"),    U(API_KEY));
req.headers().add(U("Content-Type"), U("application/json"));
req.set_body(startBody);
auto resp = client.request(req).get();
auto j    = resp.extract_json().get();
auto sid  = j[U("data")][U("session_id")].as_string();

// Step 2 — send a user message
json::value msgBody;
msgBody[U("session_id")] = json::value::string(sid);
msgBody[U("message")]    = json::value::string(U("Will I get the promotion this year?"));

http_request msg(methods::POST);
msg.set_request_uri(U("/message"));
msg.headers().add(U("X-Api-Key"),    U(API_KEY));
msg.headers().add(U("Content-Type"), U("application/json"));
msg.set_body(msgBody);
auto reply = client.request(msg).get().extract_json().get();