Tarot

Tarot card draws and fixed spreads.

15 endpoints. Every endpoint is POST with a JSON body and your key in the Authorization header. Request schemas and examples come from the OpenAPI document; each example response was captured from the live engine and its data fields are a guide to the shape, not a contract.

Tarot Card Draw

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-shuffle

Turns over the top N cards (1-78) of a shuffled deck with orientation, keywords and element; a draw can be replayed by its draw_id, or fixed for the day.

Credits: 1 credit
Input: No input
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`count`integerOptional	Cards to turn over. Default: `3` Limits: minimum 1, maximum 78 Example: `3`
`reversals`booleanOptional	Default: `true`
`draw_id`string \| nullOptional	Replay a previous shuffle. Default: `null` Limits: at most 64 characters
`daily`booleanOptional	The stable deck of the day instead of a new shuffle. Default: `false`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
draw_id · string
daily · boolean
replayable · boolean
day · null
description · string
cards · array of object
dominant_element · string
major_arcana_count · integer
total_cards_shown · integer

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-shuffle \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "count": 3
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-shuffle", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "count": 3
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotShuffle({
  "count": 3
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-shuffle",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "count": 3,
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_shuffle({
    "count": 3,
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-shuffle');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'count' => 3,
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "count": 3
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-shuffle", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "shuffle_deck",
    "draw_id": "cfbf4d7ce7f94824bb88d5b341cf7811",
    "daily": false,
    "replayable": true,
    "day": null,
    "description": "A freshly shuffled deck. Keep the draw_id to see this same deck again; shuffle without one for a new deck.",
    "cards": [
      {
        "position": 1,
        "card_id": 58,
        "card_name": "Nine of Swords",
        "arcana": "Minor",
        "suit": "Swords",
        "orientation": "upright",
        "keywords": [
          "Anxiety",
          "Worry",
          "Fear"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Yes / No

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-yes-no

Draws cards for the Yes / No spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
question · string
answer · string
answer_score · integer
cards · array of object
summary · string
hint · string
note · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-yes-no \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-yes-no", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotYesNo({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-yes-no",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_yes_no({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-yes-no');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-yes-no", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "yes_no",
    "question": "What should I focus on this month?",
    "answer": "Maybe / Seek more clarity",
    "answer_score": 0,
    "cards": [
      {
        "position": 1,
        "position_name": "The Oracle",
        "position_context": "The card's energy gives a direct yes, no, or maybe answer to your question.",
        "card_id": 48,
        "card_name": "Queen of Cups",
        "arcana": "Minor",
        "suit": "Cups",
        "number": 13,
        "orientation": "upright",
        "keywords": [
          "Compassionate",
          "Caring",
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Daily Card

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-daily

Draws cards for the Daily Card spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
reading_date · string
name · string
cards · array of object
summary · string
affirmation · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-daily \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-daily", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotDaily({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-daily",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_daily({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-daily');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-daily", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "daily",
    "reading_date": "2026-10-14",
    "name": "Seeker",
    "cards": [
      {
        "position": 1,
        "position_name": "Energy of the Day",
        "position_context": "This card describes the dominant theme, opportunity, or caution for your day.",
        "card_id": 1,
        "card_name": "The Magician",
        "arcana": "Major",
        "suit": null,
        "number": 1,
        "orientation": "upright",
        "keywords": [
          "Willpower",
          "Skill",
          "Manifestation"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

POSTAvailable

Draws cards for the Fortune Cookie spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
cards · array of object
fortune · string
lucky_keywords · array of string
element · string
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-fortune-cookie \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-fortune-cookie", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotFortuneCookie({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-fortune-cookie",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_fortune_cookie({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-fortune-cookie');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-fortune-cookie", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "fortune_cookie",
    "name": "Seeker",
    "cards": [
      {
        "position": 1,
        "position_name": "Your Fortune",
        "position_context": "A single karmic message from the universe — reflect on its deeper meaning.",
        "card_id": 76,
        "card_name": "Queen of Pentacles",
        "arcana": "Minor",
        "suit": "Pentacles",
        "number": 13,
        "orientation": "reversed",
        "keywords": [
          "Financial independence",
          "Self-care",
          "Work/home conflict"
        ],
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Flirt

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-flirt

Draws cards for the Flirt spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-flirt \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-flirt", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotFlirt({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-flirt",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_flirt({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-flirt');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-flirt", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "flirt",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Their Interest in You",
        "position_context": "Reveals the level and nature of the other person's attraction toward you.",
        "card_id": 36,
        "card_name": "Ace of Cups",
        "arcana": "Minor",
        "suit": "Cups",
        "number": 1,
        "orientation": "reversed",
        "keywords": [
          "Blocked emotions",
          "Emotional pain",
          "Repressed feelings"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Love Triangle

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-love-triangle

Draws cards for the Love Triangle spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-love-triangle \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-love-triangle", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotLoveTriangle({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-love-triangle",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_love_triangle({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-love-triangle');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-love-triangle", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "love_triangle",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Your Role",
        "position_context": "Your position, feelings, and energy within this triangular dynamic.",
        "card_id": 69,
        "card_name": "Six of Pentacles",
        "arcana": "Minor",
        "suit": "Pentacles",
        "number": 6,
        "orientation": "reversed",
        "keywords": [
          "Strings-attached generosity",
          "Power dynamics",
          "Debt"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Career

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-career

Draws cards for the Career spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
major_arcana_note · string
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-career \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-career", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotCareer({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-career",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_career({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-career');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-career", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "career",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Current Career Energy",
        "position_context": "Your present professional standing, feelings, and trajectory.",
        "card_id": 0,
        "card_name": "The Fool",
        "arcana": "Major",
        "suit": null,
        "number": 0,
        "orientation": "reversed",
        "keywords": [
          "Recklessness",
          "Naivety",
          "Foolishness"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: In-Depth Love

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-in-depth-love

Draws cards for the In-Depth Love spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-in-depth-love \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-in-depth-love", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotInDepthLove({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-in-depth-love",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_in_depth_love({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-in-depth-love');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-in-depth-love", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "in_depth_love",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Your Heart",
        "position_context": "Your current emotional state and what you truly desire in love.",
        "card_id": 69,
        "card_name": "Six of Pentacles",
        "arcana": "Minor",
        "suit": "Pentacles",
        "number": 6,
        "orientation": "upright",
        "keywords": [
          "Generosity",
          "Charity",
          "Giving"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Erotic Love

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-erotic-love

Draws cards for the Erotic Love spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-erotic-love \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-erotic-love", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotEroticLove({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-erotic-love",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_erotic_love({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-erotic-love');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-erotic-love", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "erotic_love",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Passion Flame",
        "position_context": "The raw passionate energy between you — what ignites the chemistry.",
        "card_id": 11,
        "card_name": "Justice",
        "arcana": "Major",
        "suit": null,
        "number": 11,
        "orientation": "upright",
        "keywords": [
          "Fairness",
          "Truth",
          "Cause and effect"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Compatibility

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-compatibility

Draws cards for the Compatibility spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name_1`stringRequired	Limits: 1 to 120 characters Example: `Asha`
`name_2`stringRequired	Limits: 1 to 120 characters Example: `Ravi`
`reversals`booleanOptional	Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
person_1 · string
person_2 · string
cards · array of object
compatibility_score · integer
element_1 · string
element_2 · string
compatibility_description · string
score_basis · string
verdict · string
dominant_element · string
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-compatibility \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "name_1": "Asha",
  "name_2": "Ravi"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-compatibility", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "name_1": "Asha",
    "name_2": "Ravi"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotCompatibility({
  "name_1": "Asha",
  "name_2": "Ravi"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-compatibility",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "name_1": "Asha",
        "name_2": "Ravi",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_compatibility({
    "name_1": "Asha",
    "name_2": "Ravi",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-compatibility');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'name_1' => 'Asha',
        'name_2' => 'Ravi',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "name_1": "Asha",
  "name_2": "Ravi"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-compatibility", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "compatibility",
    "person_1": "Asha",
    "person_2": "Ravi",
    "cards": [
      {
        "position": 1,
        "position_name": "Your Core Energy",
        "position_context": "Your fundamental nature and what you bring to a partnership.",
        "card_id": 42,
        "card_name": "Seven of Cups",
        "arcana": "Minor",
        "suit": "Cups",
        "number": 7,
        "orientation": "reversed",
        "keywords": [
          "Alignment",
          "Personal values",
          "Overwhelm"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Romantic Breakup

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-romantic-breakup

Draws cards for the Romantic Breakup spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-romantic-breakup \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-romantic-breakup", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotRomanticBreakup({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-romantic-breakup",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_romantic_breakup({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-romantic-breakup');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-romantic-breakup", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "romantic_breakup",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Root Cause",
        "position_context": "The underlying energy or issue that led to the breakdown of love.",
        "card_id": 57,
        "card_name": "Eight of Swords",
        "arcana": "Minor",
        "suit": "Swords",
        "number": 8,
        "orientation": "reversed",
        "keywords": [
          "Self-acceptance",
          "Release",
          "New perspective"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Business Breakup

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-business-breakup

Draws cards for the Business Breakup spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-business-breakup \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-business-breakup", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotBusinessBreakup({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-business-breakup",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_business_breakup({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-business-breakup');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-business-breakup", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "business_breakup",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Core Issue",
        "position_context": "The fundamental breakdown point in the business partnership.",
        "card_id": 50,
        "card_name": "Ace of Swords",
        "arcana": "Minor",
        "suit": "Swords",
        "number": 1,
        "orientation": "upright",
        "keywords": [
          "Breakthrough",
          "New idea",
          "Mental clarity"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Past, Present, Future

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-past-present-future

Draws cards for the Past, Present, Future spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-past-present-future \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-past-present-future", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotPastPresentFuture({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-past-present-future",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_past_present_future({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-past-present-future');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-past-present-future", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "past_present_future",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Past",
        "position_context": "The roots of the matter — past influences, patterns and karma that set the stage.",
        "card_id": 20,
        "card_name": "Judgement",
        "arcana": "Major",
        "suit": null,
        "number": 20,
        "orientation": "upright",
        "keywords": [
          "Reflection",
          "Reckoning",
          "Awakening"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Celtic Cross

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-celtic-cross

Draws cards for the Celtic Cross spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-celtic-cross \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-celtic-cross", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotCelticCross({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-celtic-cross",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_celtic_cross({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-celtic-cross');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-celtic-cross", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "celtic_cross",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "The Heart of the Matter",
        "position_context": "The core of your question and your present situation.",
        "card_id": 17,
        "card_name": "The Star",
        "arcana": "Major",
        "suit": null,
        "number": 17,
        "orientation": "reversed",
        "keywords": [
          "Lack of faith",
          "Despair",
          "Disconnection"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot: Year Ahead

POSTAvailable

https://api.96astro.com/v1/tarot/tarot-year-ahead

Draws cards for the Year Ahead spread and returns them with a reading.

Credits: 1 credit
Input: Name
Output: JSON
Delivery: Direct response
Languages: English; translated term names with labels

Headers
Header	Value and description
`Authorization`Required	`Bearer YOUR_API_KEY` Your sandbox (sk_test_...) or live (sk_live_...) key. X-API-Key: <key> is accepted instead.
`Content-Type`Required	`application/json` The body is JSON.
`Idempotency-Key`Optional	`<unique string>` Makes retries safe: a repeated key with the same body replays the stored response and is never charged twice. (1 to 200 characters)

Body · application/json
Field	Description
`name`stringOptional	Default: `""` Limits: at most 120 characters
`question`stringOptional	Default: `""` Limits: at most 500 characters Example: `What should I focus on this month?`
`reversals`booleanOptional	Allow reversed cards. Default: `true`
`labels`stringOptional	Optional. Adds `meta.labels`: translated display names for the identifiers in the answer. `data` is unchanged. Free. Any other code is refused with 422 unsupported_language. Allowed values: asbndeesfrguhiitknkomlmrnenlorpaplptrusitatetrur

Response · fields in data

Inferred from the example response: a guide to the shape, not a contract.

reading_type · string
name · string
question · string
cards · array of object
dominant_element · string
major_arcana_count · integer
summary · string

Try in Playground →Capability overview

Example request

curl -X POST https://api.96astro.com/v1/tarot/tarot-year-ahead \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "question": "What should I focus on this month?"
}'

const response = await fetch("https://api.96astro.com/v1/tarot/tarot-year-ahead", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "question": "What should I focus on this month?"
  }),
});

const { data, meta } = await response.json();
console.log(data);

import { Astro96Client } from "@96astro/api";

const astro = new Astro96Client({ apiKey: "YOUR_API_KEY" });

const { data, meta } = await astro.tarot.tarotYearAhead({
  "question": "What should I focus on this month?"
});
console.log(data);

import requests

response = requests.post(
    "https://api.96astro.com/v1/tarot/tarot-year-ahead",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "question": "What should I focus on this month?",
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()["data"]
print(data)

from astro96_api import Astro96Client

astro = Astro96Client(api_key="YOUR_API_KEY")

res = astro.tarot.tarot_year_ahead({
    "question": "What should I focus on this month?",
})
print(res.data)

<?php
$ch = curl_init('https://api.96astro.com/v1/tarot/tarot-year-ahead');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'question' => 'What should I focus on this month?',
    ]),
]);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true);
print_r($result['data']);

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	body := strings.NewReader(`{
  "question": "What should I focus on this month?"
}`)
	req, err := http.NewRequest("POST", "https://api.96astro.com/v1/tarot/tarot-year-ahead", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.Status, string(out))
}

Example response

200application/json

{
  "data": {
    "reading_type": "year_ahead",
    "name": "Seeker",
    "question": "What should I focus on this month?",
    "cards": [
      {
        "position": 1,
        "position_name": "Month 1",
        "position_context": "The theme, opportunity and caution of the coming first month.",
        "card_id": 57,
        "card_name": "Eight of Swords",
        "arcana": "Minor",
        "suit": "Swords",
        "number": 8,
        "orientation": "upright",
        "keywords": [
          "Imprisonment",
          "Entrapment",
          "Self-victimisation"
  …

Captured from the live engine with a sandbox key (so credits_used is 0) and trimmed: long arrays keep their first items.

Error responses

400invalid_request
401invalid_key, expired_key
402payment_required
403account_suspended
404not_found
409idempotency_conflict
413payload_too_large
422invalid_request, unsupported_language
429rate_limited, quota_exhausted, spend_cap_reached, project_budget_exceeded
500computation_failed
502unavailable
503unavailable
504deadline_exceeded

Errors are never charged. What each status means and what to do: errors.

Tarot

Tarot Card Draw

Example request

Example response

Error responses

Tarot: Yes / No

Example request

Example response

Error responses

Tarot: Daily Card

Example request

Example response

Error responses

Tarot: Fortune Cookie

Example request

Example response

Error responses

Tarot: Flirt

Example request

Example response

Error responses

Tarot: Love Triangle

Example request

Example response

Error responses

Tarot: Career

Example request

Example response

Error responses

Tarot: In-Depth Love

Example request

Example response

Error responses

Tarot: Erotic Love

Example request

Example response

Error responses

Tarot: Compatibility

Example request

Example response

Error responses

Tarot: Romantic Breakup

Example request

Example response

Error responses

Tarot: Business Breakup

Example request

Example response

Error responses

Tarot: Past, Present, Future

Example request

Example response

Error responses

Tarot: Celtic Cross

Example request

Example response

Error responses

Tarot: Year Ahead

Example request

Example response

Error responses