Talk to the world's first real-time AI voice astrologer. Real charts.

# Phase 1 — create the session (REST)
curl -X POST https://starsapi.com/api/v2/partner/ai/voice/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"
  }\'

# Returns:  data.session_id

# Phase 2 — open the WebSocket (use a tool like websocat for testing)
websocat wss://starsapi.com/voice-relay-v2

# Send auth frame as your first message:
{"type":"auth","session_id":"abc123...","api_key":"YOUR_KEY","name":"Ravi","lang":"en"}

# Wait for: {"type":"ready", ...}
# Then send: {"type":"greet","name":"Ravi","lang":"en"}
# Then stream audio chunks: {"type":"audio.chunk","data":"BASE64_PCM_24KHZ_MONO"}

const BASE = "https://starsapi.com/api/v2/partner/ai/voice";
const RELAY = "wss://starsapi.com/voice-relay-v2";

// Phase 1 — REST: create the session
const r = await fetch(`${BASE}/start`, {
  method:  "POST",
  headers: { "X-Api-Key": API_KEY, "Content-Type": "application/json" },
  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 = r.data.session_id;

// Phase 2 — WebSocket: real-time conversation
const ws = new WebSocket(RELAY);
ws.onopen = () => ws.send(JSON.stringify({
  type: "auth", session_id: sessionId, api_key: API_KEY,
  name: "Ravi", lang: "en",
}));

ws.onmessage = (e) => {
  const f = JSON.parse(e.data);
  switch (f.type) {
    case "ready":            ws.send(JSON.stringify({ type: "greet", name: "Ravi", lang: "en" })); break;
    case "user.speech_started":  if (assistantPlaying) ws.send(JSON.stringify({ type: "interrupt" })); break;
    case "user.transcript":      renderUserBubble(f.text); break;
    case "assistant.audio":      playPcmChunk(base64ToBytes(f.data)); break;
    case "assistant.transcript": appendAssistantCaption(f.delta); break;
    case "assistant.done":       enableMic(); break;
    case "billing.exhausted":    showTopUp(); break;
    case "error":                console.error(f.code, f.message); break;
  }
};

// Send mic chunks as they arrive (24kHz mono PCM s16le, base64-encoded)
function onMicChunk(int16Pcm) {
  ws.send(JSON.stringify({ type: "audio.chunk", data: bytesToBase64(int16Pcm) }));
}

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

const BASE  = 'https://starsapi.com/api/v2/partner/ai/voice';
const RELAY = 'wss://starsapi.com/voice-relay-v2';

// Phase 1 — REST: create the session
final r = await http.post(
  Uri.parse('$BASE/start'),
  headers: { 'X-Api-Key': apiKey, 'Content-Type': 'application/json' },
  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 sessionId = jsonDecode(r.body)['data']['session_id'];

// Phase 2 — WebSocket: real-time conversation
final ws = WebSocketChannel.connect(Uri.parse(RELAY));
ws.sink.add(jsonEncode({
  'type': 'auth', 'session_id': sessionId, 'api_key': apiKey,
  'name': 'Ravi', 'lang': 'en',
}));

ws.stream.listen((raw) {
  final f = jsonDecode(raw);
  switch (f['type']) {
    case 'ready':
      ws.sink.add(jsonEncode({ 'type': 'greet', 'name': 'Ravi', 'lang': 'en' })); break;
    case 'user.speech_started':
      if (assistantPlaying) ws.sink.add(jsonEncode({ 'type': 'interrupt' })); break;
    case 'user.transcript':       renderUserBubble(f['text']); break;
    case 'assistant.audio':       playPcmChunk(base64Decode(f['data'])); break;
    case 'assistant.transcript':  appendCaption(f['delta']); break;
    case 'assistant.done':        enableMic(); break;
    case 'billing.exhausted':     showTopUp(); break;
  }
});

// Stream mic — capture 24kHz mono s16le PCM and send base64 chunks
void onMicChunk(Uint8List pcm) {
  ws.sink.add(jsonEncode({ 'type': 'audio.chunk', 'data': base64Encode(pcm) }));
}

import requests, json, base64
import websocket  # pip install websocket-client

BASE  = "https://starsapi.com/api/v2/partner/ai/voice"
RELAY = "wss://starsapi.com/voice-relay-v2"

# Phase 1 — REST: create the session
r = requests.post(f"{BASE}/start",
    headers={ "X-Api-Key": API_KEY, "Content-Type": "application/json" },
    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 = r["data"]["session_id"]

# Phase 2 — WebSocket: real-time conversation
def on_message(ws, raw):
    f = json.loads(raw)
    t = f["type"]
    if t == "ready":
        ws.send(json.dumps({ "type": "greet", "name": "Ravi", "lang": "en" }))
    elif t == "user.speech_started" and assistant_playing:
        ws.send(json.dumps({ "type": "interrupt" }))
    elif t == "user.transcript":      render_user_bubble(f["text"])
    elif t == "assistant.audio":      play_pcm_chunk(base64.b64decode(f["data"]))
    elif t == "assistant.transcript": append_caption(f["delta"])
    elif t == "assistant.done":       enable_mic()
    elif t == "billing.exhausted":    show_top_up()

def on_open(ws):
    ws.send(json.dumps({
        "type": "auth", "session_id": session_id, "api_key": API_KEY,
        "name": "Ravi", "lang": "en",
    }))

ws = websocket.WebSocketApp(RELAY, on_open=on_open, on_message=on_message)

# Stream mic chunks (24kHz mono s16le PCM, base64-encoded)
def send_mic_chunk(pcm: bytes):
    ws.send(json.dumps({ "type": "audio.chunk", "data": base64.b64encode(pcm).decode() }))

ws.run_forever()

// Requires: java-websocket (org.java-websocket:Java-WebSocket) + Jackson.

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import com.fasterxml.jackson.databind.*;
import java.net.URI;
import java.net.http.*;
import java.util.Base64;

static final String BASE  = "https://starsapi.com/api/v2/partner/ai/voice";
static final URI    RELAY = URI.create("wss://starsapi.com/voice-relay-v2");
static final ObjectMapper M = new ObjectMapper();

// Phase 1 — REST: create the session
String body = 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> rest = HttpClient.newHttpClient().send(
    HttpRequest.newBuilder(URI.create(BASE + "/start"))
        .header("X-Api-Key",    API_KEY)
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body)).build(),
    HttpResponse.BodyHandlers.ofString());
String sessionId = M.readTree(rest.body()).get("data").get("session_id").asText();

// Phase 2 — WebSocket
WebSocketClient ws = new WebSocketClient(RELAY) {
  @Override public void onOpen(ServerHandshake h) {
    send(M.writeValueAsString(Map.of(
      "type","auth","session_id",sessionId,"api_key",API_KEY,
      "name","Ravi","lang","en")));
  }
  @Override public void onMessage(String raw) {
    JsonNode f; try { f = M.readTree(raw); } catch(Exception e){ return; }
    switch (f.get("type").asText()) {
      case "ready":               send(M.writeValueAsString(Map.of(
                                    "type","greet","name","Ravi","lang","en")));      break;
      case "user.speech_started": if (assistantPlaying) send("{\"type\":\"interrupt\"}");   break;
      case "assistant.audio":     playPcmChunk(Base64.getDecoder().decode(f.get("data").asText())); break;
      case "assistant.transcript":appendCaption(f.get("delta").asText());                   break;
      case "assistant.done":      enableMic();                                              break;
      case "billing.exhausted":   showTopUp();                                              break;
    }
  }
  @Override public void onClose(int c, String r, boolean rem) {}
  @Override public void onError(Exception e) {}
};
ws.connect();

// Stream mic — base64 24kHz mono s16le chunks
void onMicChunk(byte[] pcm) throws Exception {
  ws.send(M.writeValueAsString(Map.of(
    "type", "audio.chunk", "data", Base64.getEncoder().encodeToString(pcm))));
}

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "net/http"
    "github.com/gorilla/websocket"
)

const (
    base  = "https://starsapi.com/api/v2/partner/ai/voice"
    relay = "wss://starsapi.com/voice-relay-v2"
)

func main() {
    // Phase 1 — REST: create the session
    payload, _ := json.Marshal(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",
    })
    req, _ := http.NewRequest("POST", base+"/start", bytes.NewReader(payload))
    req.Header.Set("X-Api-Key",    apiKey)
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    var startResp struct{ Data struct{ SessionID string `json:"session_id"` } }
    json.NewDecoder(resp.Body).Decode(&startResp)
    sid := startResp.Data.SessionID

    // Phase 2 — WebSocket
    ws, _, _ := websocket.DefaultDialer.Dial(relay, nil)
    defer ws.Close()
    ws.WriteJSON(map[string]any{
        "type": "auth", "session_id": sid, "api_key": apiKey,
        "name": "Ravi", "lang": "en",
    })

    go func() {
        for {
            var f map[string]any
            if err := ws.ReadJSON(&f); err != nil { return }
            switch f["type"] {
            case "ready":
                ws.WriteJSON(map[string]any{ "type": "greet", "name": "Ravi", "lang": "en" })
            case "user.speech_started":
                if assistantPlaying { ws.WriteJSON(map[string]any{ "type": "interrupt" }) }
            case "assistant.audio":
                pcm, _ := base64.StdEncoding.DecodeString(f["data"].(string))
                playPcmChunk(pcm)
            case "assistant.transcript":
                appendCaption(f["delta"].(string))
            case "assistant.done":
                enableMic()
            case "billing.exhausted":
                showTopUp()
            }
        }
    }()

    // Stream mic — base64-encoded 24kHz mono s16le
    onMicChunk := func(pcm []byte) {
        ws.WriteJSON(map[string]any{ "type": "audio.chunk", "data": base64.StdEncoding.EncodeToString(pcm) })
    }
    _ = onMicChunk
    select {}
}

// Requires: cpprestsdk (HTTP) + Boost.Beast or libwebsockets (WS) + base64 helper.
// Sketch using cpprestsdk for HTTP and a generic WS client interface.

#include <cpprest/http_client.h>
#include <cpprest/json.h>
#include "WsClient.h"   // your WebSocket wrapper

using namespace web;
using namespace web::http;
using namespace web::http::client;

const auto BASE  = U("https://starsapi.com/api/v2/partner/ai/voice");
const auto RELAY = U("wss://starsapi.com/voice-relay-v2");

// Phase 1 — REST
http_client rest(BASE);
json::value body;
body[U("astrologer")]         = json::value::string(U("guruji"));
body[U("year")] = 1990; body[U("month")] = 6; body[U("day")] = 15;
body[U("hour")] = 14;   body[U("minute")] = 30; body[U("timezone")] = 5.5;
body[U("latitude")]  = 28.6139; body[U("longitude")] = 77.2090;
body[U("name")]          = json::value::string(U("Ravi"));
body[U("gender")]        = json::value::string(U("male"));
body[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(body);
auto resp = rest.request(req).get();
auto json = resp.extract_json().get();
auto sid  = json[U("data")][U("session_id")].as_string();

// Phase 2 — WebSocket
WsClient ws(RELAY);
ws.on_open([&] {
    json::value auth;
    auth[U("type")]       = json::value::string(U("auth"));
    auth[U("session_id")] = json::value::string(sid);
    auth[U("api_key")]    = json::value::string(U(API_KEY));
    auth[U("name")]  = json::value::string(U("Ravi"));
    auth[U("lang")]       = json::value::string(U("en"));
    ws.send(auth.serialize());
});
ws.on_message([&](const std::string& raw) {
    auto f = json::value::parse(raw);
    auto type = f[U("type")].as_string();
    if      (type == U("ready"))                ws.send(R"({"type":"greet","name":"Ravi","lang":"en"})");
    else if (type == U("user.speech_started"))  { if (assistantPlaying) ws.send(R"({"type":"interrupt"})"); }
    else if (type == U("assistant.audio"))      playPcmChunk(base64_decode(f[U("data")].as_string()));
    else if (type == U("assistant.transcript")) appendCaption(f[U("delta")].as_string());
    else if (type == U("assistant.done"))       enableMic();
    else if (type == U("billing.exhausted"))    showTopUp();
});
ws.connect();

// Stream mic — base64-encoded 24kHz mono s16le PCM
void on_mic_chunk(const std::vector<uint8_t>& pcm) {
    ws.send("{\"type\":\"audio.chunk\",\"data\":\"" + base64_encode(pcm) + "\"}");
}