RoxyAPI Go SDK

roxy, err := roxyapi.NewRoxy(os.Getenv("ROXY_API_KEY"))
if err != nil {
	panic(err)
}
horoscope, err := roxy.Astrology.GetDailyHoroscope(context.Background(), "aries", nil)
if err != nil {
	panic(err) // a 4xx or 5xx is returned as *roxyapi.RoxyError
}
fmt.Println(horoscope.JSON200.Overview, horoscope.JSON200.Love, horoscope.JSON200.LuckyNumber)

package main

import (
	"context"
	"fmt"
	"os"
	"time"

	roxyapi "github.com/RoxyAPI/sdk-go"
)

func main() {
	roxy, err := roxyapi.NewRoxy(os.Getenv("ROXY_API_KEY"))
	if err != nil {
		panic(err)
	}
	ctx := context.Background()

	// Step 1: geocode the birth city once. Every chart endpoint takes these three values.
	search, err := roxy.Location.SearchCities(ctx, &roxyapi.SearchCitiesParams{Q: "London"})
	if err != nil {
		panic(err)
	}
	if len(search.JSON200.Cities) == 0 {
		panic("no city matched the search") // a 200 can still return zero cities
	}
	city := search.JSON200.Cities[0] // City, Country, Latitude, Longitude, Timezone (IANA), UtcOffset

	// Step 2: a Western natal chart. Timezone is a per-request union; pass the IANA string
	// from the lookup ("Europe/London") and the server resolves it to the DST-correct
	// offset for the date of the chart.
	var tz roxyapi.NatalChartRequest_Timezone
	_ = tz.FromNatalChartRequestTimezone1(city.Timezone)
	chart, err := roxy.Astrology.GenerateNatalChart(ctx, nil, roxyapi.NatalChartRequest{
		Date:     roxyapi.Date(1990, time.January, 15),
		Time:     "14:30:00",
		Latitude: city.Latitude, Longitude: city.Longitude, Timezone: tz,
	})
	if err != nil {
		panic(err)
	}

	// Step 3: the same birth as a Vedic kundli. Same inputs, sidereal zodiac. Vedic bodies
	// take Timezone as an optional pointer (omit it to default to IST).
	var vtz roxyapi.BirthChartRequest_Timezone
	_ = vtz.FromBirthChartRequestTimezone1(city.Timezone)
	kundli, err := roxy.VedicAstrology.GenerateBirthChart(ctx, nil, roxyapi.BirthChartRequest{
		Date:     roxyapi.Date(1990, time.January, 15),
		Time:     "14:30:00",
		Latitude: city.Latitude, Longitude: city.Longitude, Timezone: &vtz,
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(chart.JSON200.Ascendant.Sign, kundli.JSON200.Meta["Moon"].Rashi)
}

// One lookup feeds every chart below. Timezone is the IANA name from the city
// record; the server resolves it to the DST-correct offset for the date of each chart.
place, err := roxy.Location.SearchCities(ctx, &roxyapi.SearchCitiesParams{Q: "New York"})
if err != nil {
	return err
}
city := place.JSON200.Cities[0]
latitude, longitude, timezone := city.Latitude, city.Longitude, city.Timezone
birthDate, birthTime := roxyapi.Date(1990, time.January, 15), "14:30:00"

// A second person for the two-chart calls (synastry, Guna Milan, Human Design connection).
london, err := roxy.Location.SearchCities(ctx, &roxyapi.SearchCitiesParams{Q: "London"})
if err != nil {
	return err
}
partner := london.JSON200.Cities[0] // Latitude, Longitude and Timezone for the second chart
partnerDate, partnerTime := roxyapi.Date(1992, time.July, 22), "09:00:00"

// Natal chart. The most requested Western call, run once at onboarding.
// The body carries the latitude, longitude and timezone from the location lookup above.
var natalTz roxyapi.NatalChartRequest_Timezone
_ = natalTz.FromNatalChartRequestTimezone1(timezone)
natal, err := roxy.Astrology.GenerateNatalChart(ctx, nil, roxyapi.NatalChartRequest{
	Date: birthDate, Time: birthTime, Latitude: latitude, Longitude: longitude, Timezone: natalTz,
})
if err != nil {
	return err
}
// natal.JSON200.Planets[n].Name, .Sign, .House, .Interpretation.Summary; natal.JSON200.Ascendant.Sign; natal.JSON200.Aspects

// Daily horoscope. The highest per-user call frequency in the catalog: daily content, streaks, push.
horoscope, err := roxy.Astrology.GetDailyHoroscope(ctx, "aries", nil)
if err != nil {
	return err
}
// horoscope.JSON200.Overview, .Love, .Career, .Column, .Events, .LuckyNumber

// Synastry. Full inter-aspect analysis between two charts, the relationship feature of dating apps.
// Person1 and Person2 are inline structs, so the body is filled field by field from the two lookups above.
var synastryBody roxyapi.CalculateSynastryJSONRequestBody
synastryBody.Person1.Date, synastryBody.Person1.Time = birthDate, birthTime
synastryBody.Person1.Latitude, synastryBody.Person1.Longitude = latitude, longitude
_ = synastryBody.Person1.Timezone.FromCalculateSynastryJSONBodyPerson1Timezone1(timezone)
synastryBody.Person2.Date, synastryBody.Person2.Time = partnerDate, partnerTime
synastryBody.Person2.Latitude, synastryBody.Person2.Longitude = partner.Latitude, partner.Longitude
_ = synastryBody.Person2.Timezone.FromCalculateSynastryJSONBodyPerson2Timezone1(partner.Timezone)
synastry, err := roxy.Astrology.CalculateSynastry(ctx, nil, synastryBody)
if err != nil {
	return err
}
// synastry.JSON200.CompatibilityScore, .InterAspects, .Analysis.Strengths

// Moon phase. A zero-setup GET for wellness, cycle-tracking and meditation apps.
moon, err := roxy.Astrology.GetCurrentMoonPhase(ctx, nil)
if err != nil {
	return err
}
// moon.JSON200.Phase, .Illumination, .Sign, .Meaning.Description

// Vedic kundli. The same birth read sidereally: the body reuses the location lookup above.
// Vedic bodies take Timezone as an optional pointer; omit it to default to IST.
var kundliTz roxyapi.BirthChartRequest_Timezone
_ = kundliTz.FromBirthChartRequestTimezone1(timezone)
kundli, err := roxy.VedicAstrology.GenerateBirthChart(ctx, nil, roxyapi.BirthChartRequest{
	Date: birthDate, Time: birthTime, Latitude: latitude, Longitude: longitude, Timezone: &kundliTz,
})
if err != nil {
	return err
}
// kundli.JSON200.Meta["Moon"].Rashi, kundli.JSON200.Meta["Moon"].Nakshatra.Name, kundli.JSON200.Houses, .Combustion

// Detailed panchang. Tithi, nakshatra, yoga, karana, rahu kaal and the muhurtas for a date and place.
var panchangTz roxyapi.GetDetailedPanchangJSONBody_Timezone
_ = panchangTz.FromGetDetailedPanchangJSONBodyTimezone1(timezone)
panchang, err := roxy.VedicAstrology.GetDetailedPanchang(ctx, nil, roxyapi.GetDetailedPanchangJSONRequestBody{
	Date: roxyapi.Date(2026, time.October, 1), Latitude: latitude, Longitude: longitude, Timezone: &panchangTz,
})
if err != nil {
	return err
}
// panchang.JSON200.Tithi, .Nakshatra, .RahuKaal, .AbhijitMuhurta

// Vimshottari dasha. The mahadasha, antardasha and pratyantardasha running right now.
var dashaTz roxyapi.GetCurrentDashaJSONBody_Timezone
_ = dashaTz.FromGetCurrentDashaJSONBodyTimezone1(timezone)
dasha, err := roxy.VedicAstrology.GetCurrentDasha(ctx, nil, roxyapi.GetCurrentDashaJSONRequestBody{
	Date: birthDate, Time: birthTime, Latitude: latitude, Longitude: longitude, Timezone: &dashaTz,
})
if err != nil {
	return err
}
// dasha.JSON200.Mahadasha, .Antardasha, .RemainingInMahadasha

// Mangal Dosha. The most asked matrimonial check.
var doshaTz roxyapi.ManglikRequest_Timezone
_ = doshaTz.FromManglikRequestTimezone1(timezone)
dosha, err := roxy.VedicAstrology.CheckManglikDosha(ctx, nil, roxyapi.ManglikRequest{
	Date: birthDate, Time: birthTime, Latitude: latitude, Longitude: longitude, Timezone: &doshaTz,
})
if err != nil {
	return err
}
// dosha.JSON200.Present; Severity and Remedies are pointers, set only when Present is true

// Guna Milan. The 36-point Ashtakoota score behind kundli matching, both people from the lookups above.
var milanBody roxyapi.CompatibilityRequest
milanBody.Person1.Date, milanBody.Person1.Time = birthDate, birthTime
milanBody.Person1.Latitude, milanBody.Person1.Longitude = latitude, longitude
milanBody.Person1.Timezone = new(roxyapi.CompatibilityRequest_Person1_Timezone)
_ = milanBody.Person1.Timezone.FromCompatibilityRequestPerson1Timezone1(timezone)
milanBody.Person2.Date, milanBody.Person2.Time = partnerDate, partnerTime
milanBody.Person2.Latitude, milanBody.Person2.Longitude = partner.Latitude, partner.Longitude
milanBody.Person2.Timezone = new(roxyapi.CompatibilityRequest_Person2_Timezone)
_ = milanBody.Person2.Timezone.FromCompatibilityRequestPerson2Timezone1(partner.Timezone)
milan, err := roxy.VedicAstrology.CalculateGunMilan(ctx, nil, milanBody)
if err != nil {
	return err
}
// milan.JSON200.Total, .Percentage, .IsCompatible, .Breakdown

// KP ruling planets. Horary answers at the moment of the question, for the place looked up above.
var kpTz roxyapi.GetKpRulingPlanetsJSONBody_Timezone
_ = kpTz.FromGetKpRulingPlanetsJSONBodyTimezone1(timezone)
kp, err := roxy.VedicAstrology.GetKpRulingPlanets(ctx, nil, roxyapi.GetKpRulingPlanetsJSONRequestBody{
	Latitude: latitude, Longitude: longitude, Timezone: &kpTz,
})
if err != nil {
	return err
}
// kp.JSON200.DayLord, .MoonSublord, .RulingPlanets

// Transit forecast. Transit-to-natal aspects, sign ingresses and retrograde stations over a window.
// BirthData is an inline struct carrying the same birth: date, time, latitude, longitude, timezone.
var transitsBody roxyapi.ForecastTransitsJSONRequestBody
transitsBody.BirthData.Date, transitsBody.BirthData.Time = birthDate, birthTime
transitsBody.BirthData.Latitude, transitsBody.BirthData.Longitude = roxyapi.Ptr(latitude), roxyapi.Ptr(longitude)
_ = transitsBody.BirthData.Timezone.FromForecastTransitsJSONBodyBirthDataTimezone1(timezone)
transitsBody.StartDate, transitsBody.EndDate = roxyapi.Ptr(roxyapi.Date(2026, time.October, 1)), roxyapi.Ptr(roxyapi.Date(2026, time.October, 31))
transits, err := roxy.Forecast.ForecastTransits(ctx, nil, transitsBody)
if err != nil {
	return err
}
// transits.JSON200.Count, transits.JSON200.Events[n].Date, .Type, .Body, .Target, .Aspect, .Significance

// Cross-domain timeline. The same window with Vedic dasha boundaries and biorhythm critical days merged in.
var timelineBody roxyapi.GenerateTimelineJSONRequestBody
timelineBody.BirthData.Date, timelineBody.BirthData.Time = birthDate, birthTime
timelineBody.BirthData.Latitude, timelineBody.BirthData.Longitude = roxyapi.Ptr(latitude), roxyapi.Ptr(longitude)
_ = timelineBody.BirthData.Timezone.FromGenerateTimelineJSONBodyBirthDataTimezone1(timezone)
timelineBody.StartDate, timelineBody.EndDate = roxyapi.Ptr(roxyapi.Date(2026, time.October, 1)), roxyapi.Ptr(roxyapi.Date(2026, time.October, 31))
timeline, err := roxy.Forecast.GenerateTimeline(ctx, nil, timelineBody)
if err != nil {
	return err
}
// timeline.JSON200.Events[n].Domain ("western", "vedic" or "biorhythm"), .Description, .Significance

// Bodygraph. Type, strategy, authority, profile, definition, centers, channels and all 26 gates in one call.
// Human Design needs only the birth instant, so it takes the date, time and timezone from the lookup above.
var hdTz roxyapi.GenerateBodygraphJSONBody_Timezone
_ = hdTz.FromGenerateBodygraphJSONBodyTimezone1(timezone)
hd, err := roxy.HumanDesign.GenerateBodygraph(ctx, nil, roxyapi.GenerateBodygraphJSONRequestBody{
	Date: birthDate, Time: birthTime, Timezone: hdTz,
})
if err != nil {
	return err
}
// hd.JSON200.Type, .Strategy, .Authority, .Profile, .Definition, .IncarnationCross.Name, .Centers, .Channels, .Gates

// Connection. Two bodygraphs combined, each of the 36 channels classified by how the pair forms it.
var connectionBody roxyapi.CalculateConnectionJSONRequestBody
connectionBody.PersonA.Date, connectionBody.PersonA.Time = birthDate, birthTime
_ = connectionBody.PersonA.Timezone.FromCalculateConnectionJSONBodyPersonATimezone1(timezone)
connectionBody.PersonB.Date, connectionBody.PersonB.Time = partnerDate, partnerTime
_ = connectionBody.PersonB.Timezone.FromCalculateConnectionJSONBodyPersonBTimezone1(partner.Timezone)
connection, err := roxy.HumanDesign.CalculateConnection(ctx, nil, connectionBody)
if err != nil {
	return err
}
// connection.JSON200.TotalChannels, .Summary.Electromagnetic, .CombinedDefinition

// BaZi Four Pillars. The anchor call of the domain, from the same birth instant as every chart above.
// Each response echoes the Conventions it was computed under, so a chart can be reproduced, not guessed.
var baziTz roxyapi.GenerateBaziChartJSONBody_Timezone
_ = baziTz.FromGenerateBaziChartJSONBodyTimezone1(timezone)
bazi, err := roxy.ChineseAstrology.GenerateBaziChart(ctx, nil, roxyapi.GenerateBaziChartJSONRequestBody{
	Date: birthDate, Time: birthTime, Timezone: baziTz,
})
if err != nil {
	return err
}
// bazi.JSON200.Pillars[n].Position ("year", "month", "day" or "hour"), .Stem.Element, .Branch.Animal, .TenGod.Name
// bazi.JSON200.DayMaster.Element, .ZodiacAnimal, .FiveElements, .Conventions

// Chinese zodiac animal. Defaults YearBoundary to the Lunar New Year, the folk rule people mean
// when they ask which animal they are. Pass the li-chun value for the classical BaZi boundary.
animal, err := roxy.ChineseAstrology.CalculateZodiacAnimal(ctx, nil, roxyapi.CalculateZodiacAnimalJSONRequestBody{Date: birthDate})
if err != nil {
	return err
}
// animal.JSON200.Animal.Name, .Animal.Element, .Element (the year stem element), .Interpretation

// Almanac day. The Tong Shu view of a date: day officer, mansion, clash animal, favours and avoids.
// The date is a path parameter and typed, so it takes the same Date helper as a body field.
almanac, err := roxy.ChineseAstrology.GetAlmanacDay(ctx, roxyapi.Date(2026, time.October, 1), nil)
if err != nil {
	return err
}
// almanac.JSON200.DayPillar, .DayOfficer, .ClashAnimal, .Favours, .Avoids

// Kua number. One birth date and a gender give the personal directions everything else reads off.
kua, err := roxy.FengShui.CalculateKuaNumber(ctx, nil, roxyapi.CalculateKuaNumberJSONRequestBody{
	Date: birthDate, Gender: roxyapi.CalculateKuaNumberJSONBodyGenderFemale,
})
if err != nil {
	return err
}
// kua.JSON200.Kua, .Group ("east" or "west"), .Trigram.English, kua.JSON200.Sectors[n].Direction, .Nature, .Rank

// Flying star natal chart. Period plus facing gives the nine palaces with base, mountain and water stars.
// Send Facing (a mountain id like Bing or a compass label like S2, both generated constants) or FacingDegrees, not neither.
stars, err := roxy.FengShui.GenerateFlyingStarChart(ctx, nil, roxyapi.GenerateFlyingStarChartJSONRequestBody{
	Period: roxyapi.Ptr(9), Facing: roxyapi.Ptr(roxyapi.GenerateFlyingStarChartJSONBodyFacingS2),
})
if err != nil {
	return err
}
// stars.JSON200.Facing.Label, .Sitting.Label, .Structure.Name, stars.JSON200.Palaces[n].Palace, .Base, .Mountain, .Water, .Reading

// Tzolkin day sign. The most asked Maya question, answered from a date alone.
tzolkin, err := roxy.MesoamericanAstrology.CalculateTzolkin(ctx, nil, roxyapi.CalculateTzolkinJSONRequestBody{Date: birthDate})
if err != nil {
	return err
}
// tzolkin.JSON200.DaySign, .DaySignName, .Number, .Trecena, .Reading

// Full Maya chart. Tzolkin, Haab, Long Count, Calendar Round, Lord of the Night, Year Bearer and the Cruz Maya.
maya, err := roxy.MesoamericanAstrology.GenerateMayanChart(ctx, nil, roxyapi.GenerateMayanChartJSONRequestBody{Date: birthDate})
if err != nil {
	return err
}
// maya.JSON200.Tzolkin, .Haab, .LongCount, .CalendarRound, .YearBearer, .Cross, .Conventions.Correlation

// Entrance analysis. Plot, facing and door in; the pada, its devata, the classical effect and the recommended padas out.
// Plot is an inline struct, so the body is filled field by field; the enum values are generated constants.
var entranceBody roxyapi.CalculateEntrancePadaJSONRequestBody
entranceBody.Plot.Width, entranceBody.Plot.Depth = roxyapi.Ptr[float32](30), roxyapi.Ptr[float32](40)
entranceBody.Plot.Unit = roxyapi.Ptr(roxyapi.CalculateEntrancePadaJSONBodyPlotUnitFeet)
entranceBody.Facing = roxyapi.Ptr(roxyapi.CalculateEntrancePadaJSONBodyFacingNorth)
entranceBody.DoorPosition = roxyapi.Ptr[float32](0.4)
entrance, err := roxy.Vastu.CalculateEntrancePada(ctx, nil, entranceBody)
if err != nil {
	return err
}
// entrance.JSON200.Pada, .Devata, .Effect, .Auspiciousness, .RecommendedPadas, .Source

// Room compliance. A verdict per room with the verse or the convention it rests on, and a scored composite.
// Rooms is a slice of inline structs with no named type, so this body is unmarshalled from its JSON shape.
var roomsBody roxyapi.CalculateRoomComplianceJSONRequestBody
if err := json.Unmarshal([]byte(`{
	"plot": {"width": 30, "depth": 40, "unit": "feet"},
	"facing": "North",
	"rooms": [
		{"type": "kitchen", "direction": "Southeast"},
		{"type": "master-bedroom", "direction": "Southwest"},
		{"type": "puja", "direction": "Northeast"}
	]
}`), &roomsBody); err != nil {
	return err
}
rooms, err := roxy.Vastu.CalculateRoomCompliance(ctx, nil, roomsBody)
if err != nil {
	return err
}
// rooms.JSON200.Score, rooms.JSON200.Rooms[n].Type, .Verdict, .IdealDirections, .Source

// Life Path. The most searched numerology number, from the birth date alone.
lifePath, err := roxy.Numerology.CalculateLifePath(ctx, nil, roxyapi.CalculateLifePathJSONRequestBody{Year: 1990, Month: 1, Day: 15})
if err != nil {
	return err
}
// lifePath.JSON200.Number, .Type ("single" or "master"), .Meaning

// Full numerology chart. All six core numbers plus karmic lessons, pinnacles and the personal year in one call.
numerology, err := roxy.Numerology.GenerateNumerologyChart(ctx, nil, roxyapi.GenerateNumerologyChartJSONRequestBody{
	FullName: "Jane Smith", Year: 1990, Month: 1, Day: 15,
})
if err != nil {
	return err
}
// numerology.JSON200.CoreNumbers.LifePath, .Expression, .SoulUrge, numerology.JSON200.AdditionalInsights.PersonalYear

// Personal Year. The annual theme, the January feature of every numerology app.
personalYear, err := roxy.Numerology.CalculatePersonalYear(ctx, nil, roxyapi.CalculatePersonalYearJSONRequestBody{Month: 1, Day: 15, Year: roxyapi.Ptr(2026)})
if err != nil {
	return err
}
// personalYear.JSON200.PersonalYear, .Theme, .Advice

// Gematria. A Latin name transliterated under a declared convention, ten ciphers, each with its tradition and source.
gematria, err := roxy.Kabbalah.CalculateGematria(ctx, nil, roxyapi.CalculateGematriaJSONRequestBody{Text: roxyapi.Ptr("Sarah")})
if err != nil {
	return err
}
// gematria.JSON200.Chosen.Hebrew, gematria.JSON200.Values[n].ID, .Name, .Value, .Tradition; gematria.JSON200.Matches, .Conventions

// Birth profile. The Hebrew date and birthday, the three birth angels and the birth sephirah from the instant above.
var kabbalahTz roxyapi.GenerateBirthProfileJSONBody_Timezone
_ = kabbalahTz.FromGenerateBirthProfileJSONBodyTimezone1(timezone)
kabbalah, err := roxy.Kabbalah.GenerateBirthProfile(ctx, nil, roxyapi.GenerateBirthProfileJSONRequestBody{
	Date: birthDate, Time: roxyapi.Ptr(birthTime), Timezone: kabbalahTz,
})
if err != nil {
	return err
}
// kabbalah.JSON200.HebrewDate, .HebrewBirthday, .Angels, .Sephirah

// Daily card. Deterministic per (seed, date), so one user sees one card per day.
card, err := roxy.Tarot.GetDailyCard(ctx, nil, roxyapi.GetDailyCardJSONRequestBody{Seed: roxyapi.Ptr("user-42")})
if err != nil {
	return err
}
// card.JSON200.Card.Name, .Card.Reversed, .Card.ImageURL, .DailyMessage

// Three-card spread. Past, present, future: the most drawn spread on every tarot platform.
three, err := roxy.Tarot.CastThreeCard(ctx, nil, roxyapi.CastThreeCardJSONRequestBody{Question: roxyapi.Ptr("My next quarter"), Seed: roxyapi.Ptr("user-42")})
if err != nil {
	return err
}
// three.JSON200.Positions[n].Name, .Card.Name, .Interpretation; three.JSON200.Summary

// Celtic Cross. The ten-position professional reading.
celtic, err := roxy.Tarot.CastCelticCross(ctx, nil, roxyapi.CastCelticCrossJSONRequestBody{Question: roxyapi.Ptr("What should I focus on?"), Seed: roxyapi.Ptr("user-42")})
if err != nil {
	return err
}
// celtic.JSON200.Positions[n].Name, .Card.Name, .Interpretation; celtic.JSON200.Summary

// Yes or no. One card, one answer, with its strength.
answer, err := roxy.Tarot.CastYesNo(ctx, nil, roxyapi.CastYesNoJSONRequestBody{Question: roxyapi.Ptr("Should I take the offer?")})
if err != nil {
	return err
}
// answer.JSON200.Answer ("Yes", "No" or "Maybe"), .Strength, .Card.Name

// Biorhythm reading. All ten cycles for a date, from the same birth date as every chart above.
bio, err := roxy.Biorhythm.GetReading(ctx, nil, roxyapi.GetReadingJSONRequestBody{BirthDate: birthDate, TargetDate: roxyapi.Ptr(roxyapi.Date(2026, time.October, 1))})
if err != nil {
	return err
}
// bio.JSON200.Cycles["physical"].Value, .Phase; bio.JSON200.EnergyRating, .OverallPhase, .CriticalAlerts, .Interpretation

// Forecast. Every cycle for every day of a window, with the best and worst days named.
bioForecast, err := roxy.Biorhythm.GetForecast(ctx, nil, roxyapi.GetForecastJSONRequestBody{
	BirthDate: birthDate, StartDate: roxyapi.Ptr(roxyapi.Date(2026, time.October, 1)), EndDate: roxyapi.Ptr(roxyapi.Date(2026, time.October, 31)),
})
if err != nil {
	return err
}
// bioForecast.JSON200.Summary.BestDay, .WorstDay, .AverageEnergy; bioForecast.JSON200.Days[n].Date, .Physical, .Emotional, .Intellectual, .IsCritical

// Constitution. The dosha profile read from the sidereal chart of the same birth, each factor with its verse.
var constitutionTz roxyapi.AyurvedaConstitutionRequest_Timezone
_ = constitutionTz.FromAyurvedaConstitutionRequestTimezone1(timezone)
constitution, err := roxy.Ayurveda.CalculateAyurvedicConstitution(ctx, nil, roxyapi.AyurvedaConstitutionRequest{
	Date: birthDate, Time: birthTime, Latitude: latitude, Longitude: longitude, Timezone: &constitutionTz,
})
if err != nil {
	return err
}
// constitution.JSON200.Composite.Dominant, .Type; constitution.JSON200.Factors[n].ID, .Input, .Doshas, .Source; constitution.JSON200.Meta.Disclaimer

// Dinacharya. Brahma muhurta, the dosha periods and the routine for a date at the place looked up above.
var dinacharyaTz roxyapi.AyurvedaDinacharyaRequest_Timezone
_ = dinacharyaTz.FromAyurvedaDinacharyaRequestTimezone1(timezone)
dinacharya, err := roxy.Ayurveda.GetDinacharyaSchedule(ctx, nil, roxyapi.AyurvedaDinacharyaRequest{
	Date: roxyapi.Date(2026, time.October, 1), Latitude: latitude, Longitude: longitude, Timezone: &dinacharyaTz,
})
if err != nil {
	return err
}
// dinacharya.JSON200.BrahmaMuhurta, .DoshaPeriods, .Routine

// Cast a reading. Three coins six times: the primary hexagram, the changing lines and the resulting hexagram.
reading, err := roxy.Iching.CastReading(ctx, &roxyapi.CastReadingParams{Seed: roxyapi.Ptr("user-42")})
if err != nil {
	return err
}
// reading.JSON200.Hexagram.Number, .Hexagram.English, .Lines, .ChangingLinePositions, .ResultingHexagram

// Hexagram catalog. Paginated, 20 per page by default; ask for all 64 once and cache them.
hexagrams, err := roxy.Iching.ListHexagrams(ctx, &roxyapi.ListHexagramsParams{Limit: roxyapi.Ptr(64)})
if err != nil {
	return err
}
// hexagrams.JSON200.Total, hexagrams.JSON200.Hexagrams[n].Number, .English, .Pinyin; call roxy.Iching.GetHexagram(ctx, number, nil) for the judgment and lines

// By zodiac. The most searched crystal query pattern.
bySign, err := roxy.Crystals.GetCrystalsByZodiac(ctx, "scorpio", nil)
if err != nil {
	return err
}
// bySign.JSON200.Crystals[n].ID, .Name, .ImageURL, .Colors; call roxy.Crystals.GetCrystal(ctx, id, nil) for full properties

// By chakra. Wellness and yoga content pages.
byChakra, err := roxy.Crystals.GetCrystalsByChakra(ctx, "Heart", nil)
if err != nil {
	return err
}
// byChakra.JSON200.Crystals[n].Name, .Colors

// Birthstone. Evergreen gift and jewelry pages.
birthstone, err := roxy.Crystals.GetBirthstones(ctx, 1, nil)
if err != nil {
	return err
}

// Symbol detail. Every "what does it mean to dream about X" page lands here.
symbol, err := roxy.Dreams.GetDreamSymbol(ctx, "flying") // no params argument on this endpoint
if err != nil {
	return err
}
// symbol.JSON200.ID, .Name, .Meaning

// Symbol search. Chatbots fetch the dictionary once and keep it locally.
symbols, err := roxy.Dreams.SearchDreamSymbols(ctx, &roxyapi.SearchDreamSymbolsParams{Q: roxyapi.Ptr("water")})
if err != nil {
	return err
}
// symbols.JSON200.Symbols[n].ID, .Name

// By number. Every "meaning of 1111" page is backed by this. The path param is a string.
angel, err := roxy.AngelNumbers.GetAngelNumber(ctx, "1111", nil)
if err != nil {
	return err
}
// angel.JSON200.Title, .CoreMessage, .Meaning.Spiritual, .Meaning.Love, .Affirmation

// Universal lookup. Any positive integer, with the digit root carrying the answer when no curated entry exists.
sequence, err := roxy.AngelNumbers.AnalyzeNumberSequence(ctx, &roxyapi.AnalyzeNumberSequenceParams{Number: "4242"})
if err != nil {
	return err
}
// sequence.JSON200.DigitRoot, .IsRepeating, .KnownMeaning (nil when not curated), .DigitRootMeaning.Title

resp, err := roxy.Astrology.GetDailyHoroscope(ctx, "aries", nil)
var rerr *roxyapi.RoxyError
if errors.As(err, &rerr) {
	switch rerr.Code {
	case "rate_limit_exceeded":
		// back off
	case "validation_error":
		for _, iss := range rerr.Issues { // each field that failed
			fmt.Printf("%s: %s\n", iss.Path, iss.Message)
		}
	}
}

roxy, err := roxyapi.NewRoxy(key, roxyapi.WithHTTPClient(&http.Client{Timeout: 10 * time.Second}))