:::note
**TL;DR**
- A production tarot API should ship the full 78-card deck, upright and reversed meanings, multi-card spreads including the Celtic Cross, seeded reproducible draws, card images, and clean JSON for AI readings.
- RoxyAPI covers tarot through 10+ endpoints with seeded draws, card images, and 8-language responses, bundled with 11 other domains under one flat key.
- AstrologyAPI ships a dedicated tarot product billed through a pay-per-call credit wallet.
- Cast your first seeded three-card spread with the [Tarot API](/products/tarot-api "production-ready Tarot API with spreads, daily cards, and 78-card meanings") in under an hour.
:::

Tarot is one of the stickiest categories in consumer spiritual technology. A daily card pull builds a habit, a shareable spread drives organic reach, and premium spreads monetize cleanly. The barrier to shipping a tarot app has never been lower, but every app still needs a data layer: 78 card meanings, upright and reversed interpretations, randomization, spread positions, and increasingly a structured response an LLM can turn into a personalized reading.

You can hard-code that yourself or call a tarot API that returns it as structured JSON. This guide compares the realistic options for developers, names the providers that genuinely ship a tarot product, and gives you a verified code block so you can evaluate the data before you commit. Every claim below was checked against live provider sites in June 2026.

## How do you evaluate a tarot card API?

A strong tarot API answers eight questions before you write any code: does it cover the full 78-card deck, does each card carry both upright and reversed meanings, which spreads are built in, can draws be made reproducible, are card images supplied, is the response translated, is there agent and MCP support, and how is it priced. Tarot is content rather than ephemeris, so completeness and reproducibility matter more than astronomical accuracy.

:::stat 78 cards
Full Rider-Waite-Smith deck in the RoxyAPI [Tarot API](/products/tarot-api "Tarot API with 78-card meanings, keywords, and images"), every card carrying upright and reversed meanings, keywords, and an image URL.
:::

Run each candidate against this checklist:

- **Card database completeness.** All 22 Major Arcana and 56 Minor Arcana across Cups, Wands, Swords, and Pentacles, each with name, suit, number, and meaning.
- **Upright and reversed meanings.** Both orientations per card, with enough text for a real reading.
- **Spreads, including Celtic Cross.** Single card and three-card at minimum, plus the ten-position Celtic Cross and themed love and career spreads for premium tiers.
- **Seeded reproducibility.** A seed so the same user gets the same daily card or spread across sessions.
- **Card images.** An image URL per card so you are not sourcing 78 assets by hand.
- **Localization.** Translated responses for non-English audiences.
- **Agent and MCP readiness.** A Remote MCP server so an AI agent can call tarot tools directly.
- **Pricing model.** Flat all-in versus pay-per-call, and whether other domains are bundled.

Ready to build this? The [Tarot API](/products/tarot-api "production-ready Tarot API with seeded spreads and card images") gives you seeded spreads, card images, and 8-language responses out of the box. [See pricing](/pricing "RoxyAPI pricing and plan tiers").

## How do the leading tarot APIs compare?

The tarot API field is smaller and less mature than the astrology API field. Two providers ship a genuine, documented tarot product: RoxyAPI and AstrologyAPI. Beyond those, most options are open-source card datasets, hobby APIs on marketplaces, or building it yourself. The table maps the verified capabilities of each so you can match a path to your product.

| Capability | RoxyAPI | AstrologyAPI | Open-source datasets | Marketplace APIs | Build your own |
|---|---|---|---|---|---|
| Full 78-card deck | Yes | Yes | Varies | Varies | You write 78 |
| Upright and reversed meanings | Yes | Yes | Varies | Varies | You write 156 |
| Celtic Cross spread | Yes | Yes | You build it | Limited | You build it |
| Seeded reproducible draws | Yes | Not documented | No | Rare | You build it |
| Card images included | Yes | Not documented | Varies | Rare | You source them |
| 8-language responses | Yes | Not documented | No | No | You translate |
| Remote MCP for agents | Yes | Not documented | No | No | You build it |
| Other domains, one key | 12 domains | Per-call astrology suites | None | Separate APIs | None |
| Pricing model | Flat monthly, all domains | Credit wallet, pay per call | Free data | Varies | Your time and servers |

The honest read: both named providers cover the core deck and the marquee spreads, so the decision turns on reproducibility, bundling, agent support, and how you want to be billed.

## How does each tarot data option stack up?

Each path has a clear best-fit case. The breakdown below stays factual and is sourced from each provider live in June 2026.

### RoxyAPI

RoxyAPI bundles tarot as one of 12 domains under a single key, alongside Western and Vedic astrology, numerology, Human Design, forecast, I-Ching, biorhythm, crystals, dream interpretation, angel numbers, and location. The Tarot API ships the complete 78-card Rider-Waite-Smith deck and 10+ endpoints: daily card, draw N cards, three-card, Celtic Cross, love, career, custom spreads, a yes/no oracle, the card catalog, and per-card detail. Every draw can take a seed for deterministic per-user readings, card detail returns upright, reversed, keywords, an image URL, and layered meanings, and translated responses are available through a `?lang=` parameter in 8 languages, AI-assisted and under native-speaker review. A Remote MCP server at `/mcp/tarot` exposes each endpoint as an agent tool over Streamable HTTP with no local setup, drop-in `@roxyapi/ui` web components (MIT licensed, with React wrappers and a shadcn registry) render cards and spreads from the response, and typed TypeScript, Python, and PHP SDKs generated from the spec let you call every tarot endpoint with full type safety.

### AstrologyAPI

AstrologyAPI is a long-running astrology platform that also ships a dedicated tarot product. Its public site lists a card-of-the-day endpoint and spreads built on a full 78-card engine with upright and reversed logic (verified on astrologyapi.com, June 2026). Tarot sits beside its astrology suites and is billed through a shared credit wallet: you top up credits and pay per call rather than a flat monthly fee. For a team already running astrology on that wallet, sourcing tarot from the same vendor keeps billing in one place. Seeded draws, card images, and translated tarot responses are not documented on the public product pages, so verify those against the live docs if your app depends on them.

### Open-source tarot datasets

Several JSON datasets on public repositories provide card names, meanings, and metadata you can bundle into your build. Coverage ranges from the 22 Major Arcana only to the full 78, and meaning depth varies widely. There is no endpoint, no randomization, and no spread logic: you implement shuffling, position assignment, reversed handling, and serving yourself. Best for prototyping, learning, or apps that want total control over the data and do not mind building the logic layer.

### Marketplace and build-your-own

Marketplace listings include several tarot APIs of inconsistent quality, often hobby projects with thin docs, mixed response formats, and no availability guarantee. Building from scratch means writing 156 meaning texts, a Fisher-Yates shuffle, spread configurations, reversed logic, and an internal service, then maintaining the content. Both paths trade money for time, which only pays off when you have content requirements no provider meets.

## What does a tarot API cost?

Pricing splits into two models. RoxyAPI uses flat monthly tiers where one request equals one quota unit, REST and MCP identical, and every plan includes all 12 domains. The Starter plan is 39 dollars per month for 25,000 requests, and the Professional plan is 149 dollars per month for 200,000 requests (verified in the live plan configuration, June 2026). There are no per-domain surcharges and no per-token markup, so adding numerology or horoscopes next to tarot does not change the bill.

AstrologyAPI uses a credit wallet: you receive free trial credits on signup, then top up and pay per call with no monthly commitment, and volume discounts apply as usage grows. Wallet pricing suits spiky or low-volume usage where you would rather not hold a subscription, while flat tiers suit steady traffic and multi-domain apps where the all-in price is easier to forecast as daily active users grow.

For a tarot app specifically, call volume is low per user, so the deciding factor is usually whether you also want the other domains. If tarot is the whole product, either model works. If tarot is one feature in a broader spiritual app, the bundled flat key avoids stitching and re-billing across vendors.

## How do you draw a tarot spread with the API?

The two endpoints most tarot apps start with are the card catalog, fetched once and cached, and the three-card spread, the entry reading on nearly every platform. The catalog is a GET, the spreads are POST with an optional `question` and an optional `seed`. The seed is the reproducibility lever: pass a stable per-user value and the same user sees the same draw on the same day. Tarot endpoints are not coordinate-dependent, so there is no location lookup step.

```bash
# Browse the full 78-card deck once and cache it
curl -s https://roxyapi.com/api/v2/tarot/cards \
  -H "X-API-Key: YOUR_KEY"

# Cast a seeded three-card spread (past, present, future)
curl -s -X POST https://roxyapi.com/api/v2/tarot/spreads/three-card \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question": "What should I focus on this week?", "seed": "user-42-2026-06-11"}'

# Fetch one card with Spanish meanings
curl -s "https://roxyapi.com/api/v2/tarot/cards/star?lang=es" \
  -H "X-API-Key: YOUR_KEY"
```

The three-card response returns `spread`, a `positions` array of three entries (each with a `label`, the drawn `card`, and an `interpretation`), and a combined `reading`. Card detail returns `upright`, `reversed`, `keywords`, `imageUrl`, and layered `meaning`. To wire tarot into an AI agent instead of calling REST, point the agent at the Remote MCP server through the [MCP guide](/docs/mcp "Remote MCP setup for Claude Code, Cursor, and VS Code") so it grounds every reading in real card data. Full request and response schemas live in the [`POST /tarot/spreads/three-card`](/api-reference#tag/tarot/POST/tarot/spreads/three-card "three-card tarot spread API reference") reference.

## When should you choose each option, and when to build it yourself?

There is a right answer for each profile, and naming the case where self-hosting wins is what keeps a comparison honest.

- **Choose a flat multi-domain key** when tarot is one feature in a broader spiritual app, when you also want horoscopes, numerology, or I-Ching from the same integration, when you want seeded draws and card images without building them, or when an AI agent should call tarot tools over Remote MCP.
- **Choose a pay-per-call astrology platform** when you are already running astrology on its wallet, want tarot from the same vendor, and your volume is spiky enough that per-call billing beats a subscription.
- **Choose open-source data** for prototypes, learning, or apps that demand full control of the content and accept building the shuffle, spreads, and serving layer.
- **Build it yourself** when you have unique card interpretations no provider offers and the creative control is worth writing 156 meanings, randomization, and spread logic, plus ongoing maintenance. Because tarot is editorial content rather than a calculation engine, there is no ephemeris licensing trap here: the main legal question is artwork, and the original 1909 Rider-Waite-Smith images are public domain.

For most teams shipping this quarter, the time spent recreating tarot logic exceeds a year of subscription cost, so the build case is narrower than it looks.

## FAQ

**What is the best tarot API for developers?**

For most developers, RoxyAPI is the strongest pick: a complete 78-card Rider-Waite-Smith deck with upright and reversed meanings, every major spread including Celtic Cross, seeded reproducible draws, card images, eight-language output, and Remote MCP, all under one flat-priced key that also bundles 11 other domains. A tarot-only feature bolted onto an existing pay-per-call astrology stack can be billed in place, but for a complete tarot engine with predictable pricing and AI-native tooling, start with RoxyAPI.

**Is there a tarot spread API with Celtic Cross support?**

Yes. RoxyAPI exposes a ten-position Celtic Cross spread plus three-card, love, career, custom spreads, and a yes/no oracle, each accepting an optional question and seed for reproducible draws. Open-source datasets and most marketplace APIs leave the spread logic for you to build, so a hosted spread endpoint saves real work.

**Can I get reproducible tarot draws from an API?**

Yes, if the API supports seeding. RoxyAPI tarot endpoints accept an optional seed, so passing a stable per-user value returns the same daily card or spread across sessions and devices. This is how apps give each user one consistent card of the day without storing the result. Reproducible draws are not documented on every provider, so confirm before relying on them.

**How many API calls does a tarot app generate?**

Very few per user. A daily card pull is one call and a three-card spread is one call, so an active daily user generates roughly 30 to 40 calls per month. A 25,000-request Starter plan comfortably supports more than 100 daily active users with headroom, because tarot traffic is low-volume compared with chart-heavy astrology apps.

**Can I use Rider-Waite-Smith tarot images in my app?**

The original Rider-Waite-Smith artwork, published in 1909 with illustrations by Pamela Colman Smith, is in the public domain and free to use. Some modern recolored or redrawn versions remain under copyright, so verify the specific deck. RoxyAPI returns an image URL per card, and you control your visual assets either way.

**Does a tarot card API include reversed meanings?**

A complete tarot card API returns both upright and reversed interpretations per card, since orientation changes the reading. RoxyAPI card detail returns separate upright and reversed text plus keywords and layered meanings, and draws can toggle reversals. Open-source datasets vary, so check that both orientations are present before building on one.

## Conclusion

The tarot API decision comes down to deck completeness, seeded reproducibility, spreads, images, agent support, and how you want to be billed. If tarot is one part of a larger insight product, a flat all-in key that bundles it with 11 other domains removes the most integration work. Start with the [Tarot API](/products/tarot-api "production-ready Tarot API with spreads, daily cards, and 78-card meanings") and review the [pricing tiers](/pricing "RoxyAPI pricing and plan tiers") to size your plan.