Which Yu-Gi-Oh! API? YGOPRODeck vs TCG API (2026)

Building a Yu-Gi-Oh! app? You need card data, and unlike Magic — where Scryfall is the obvious default — the Yu-Gi-Oh! API landscape is thinner and the pricing story is weaker.

This guide covers the Yu-Gi-Oh! APIs worth knowing in 2026, what each does well, where each falls short, and how to pick the right one.

Why Yu-Gi-Oh! Is Harder Than It Looks

Yu-Gi-Oh! has around 13,000 unique cards, but the card count is the easy part. The complexity is in the printings.

A single card like Ash Blossom & Joyous Spring exists across dozens of set printings, each with its own rarity — Common, Super Rare, Ultra Rare, Secret Rare, Starlight Rare — and each rarity trades at a wildly different price. A Common reprint might be $0.50 while the Starlight from the same card is $300.

That means:

• Card-level pricing is nearly meaningless. “What is Ash Blossom worth?” has no single answer.
• You need set-and-rarity-level price data to build anything useful for collectors or stores.
• Reprints move markets constantly. Yu-Gi-Oh! reprints aggressively, and a reprint announcement can halve a card’s value overnight.

Most Yu-Gi-Oh! APIs handle the card metadata well and the pricing poorly. That gap is the main thing to plan around.

Common use cases:

• Deck builders — Card search, card text, banlist status
• Collection managers — Track what you own across printings and rarities
• Price trackers — Monitor market values, catch reprint crashes
• Store tools — Inventory pricing, buylist generation
• Meta analytics — Banlist impact, archetype price trends

YGOPRODeck

YGOPRODeck is the de facto standard Yu-Gi-Oh! card database API, and for card metadata it is genuinely excellent.

What it offers:

• Complete card database with full card text, ATK/DEF, level, attribute, and type
• Card images hosted and freely accessible
• Banlist status for TCG, OCG, and GOAT formats
• Archetype tagging — query every card in an archetype in one call
• Set printing lists per card
• No authentication required

On pricing — it has more than people expect. Every card carries a card_prices block with five sources: tcgplayer_price, cardmarket_price, ebay_price, amazon_price and coolstuffinc_price. Each entry in card_sets also carries a set_price for that specific printing. If you only need one current number, this is free and it is right there.

The catch is what those five numbers mean. They are five different marketplaces, not five opinions on one price, and they diverge wildly. Checked 26 August 2026, Dark Magician returned cardmarket_price of 0.02 against an amazon_price of 14.45 — a 700x spread, because one is the cheapest European listing for any printing and the other is a different marketplace in a different currency. Averaging them produces a meaningless number. Pick the source that matches your users and ignore the rest. Some sources also return 0.00 where they have no listing — Snake-Eye Ash came back with ebay_price and amazon_price both zero — so treat zero as missing, not as free.

Limitations:

• No historical price data, so no trend analysis and no way to measure a reprint’s impact
• One current value per source — no per-condition breakdown
• Yu-Gi-Oh! only
• Rate limited to 20 requests per second, per their own API guide

Best for: Deck builders, card search, banlist tools, and anything where card text and archetypes matter more than money.

// YGOPRODeck: look up a card
const res = await fetch(
  'https://db.ygoprodeck.com/api/v7/cardinfo.php?name=Ash%20Blossom%20%26%20Joyous%20Spring'
);
const { data } = await res.json();
console.log(data[0].name, data[0].atk, data[0].desc);

Konami’s Official Card Database

Konami runs an official card database, but it is a website, not an API. There is no documented public JSON endpoint, no rate limit policy, and no stability guarantee.

What it offers:

• Authoritative card text and rulings
• The official banlist, published first here

Limitations:

• No public API. Anything you build against it is scraping, and it can break without notice
• No pricing whatsoever
• Aggressive rate limiting and bot detection
• HTML parsing required

Best for: Nothing you plan to ship. Use it as a source of truth to check against, not as a dependency.

YGOPrices (yugiohprices.com) is gone

Older Yu-Gi-Oh! tutorials, Stack Overflow answers and GitHub projects reference the YGOPrices API at yugiohprices.com — endpoints like /api/get_card_prices/{name}. That domain no longer resolves. Checked on 26 August 2026, yugiohprices.com returns no A or AAAA DNS records at all, so it is not a block or an outage — there is nothing to connect to.

If you inherited a codebase pointing at it, or followed a tutorial that did, that is why nothing works and no amount of retry logic will fix it. You need a different source.

Yu-Gi-Oh! price history

Worth stating plainly, because it is the one thing none of the free options provide: YGOPRODeck, Konami’s database and the defunct YGOPrices all give you at most a current number. None of them can tell you what a card cost last month.

That matters more in Yu-Gi-Oh! than in most games, because Konami reprints aggressively and the banlist moves quarterly. A staple can lose most of its value in a week when it appears in a new structure deck, and gain it back when it goes to one on the banlist. If your project is a collection valuator, a reprint-impact tracker, or anything that answers “should I sell now”, a single current price cannot answer the question.

TCG API tracks history per printing, which is what the reprint example further down this page is built on.

TCG API

TCG API covers the gap the others leave: real market pricing at the printing level, across Yu-Gi-Oh! and 53 other games.

What it offers:

• Real market prices sourced from TCGPlayer, refreshed daily for Yu-Gi-Oh!
• 618 Yu-Gi-Oh! sets and 47,376 cards — including every set printing, not just unique card names
• Normal and Foil prices tracked separately per printing
• Price change data over 24h, 7d, and 30d — enough to detect reprint crashes
• Per-condition price floors (Near Mint through Damaged) from live listings
• Historical price data for trend analysis
• Full-text search filterable by game, set, rarity, and price range
• Bulk endpoints for pricing up to 500 cards in one request

Limitations:

• Card metadata is pricing-oriented — no ATK/DEF, card text, or banlist status
• No hosted card images (returns TCGPlayer product URLs)
• Requires an API key (free tier: 100 requests/day)

Best for: Price tracking, collection valuation, store inventory tools, and anything multi-game.

// TCG API: current prices for a Yu-Gi-Oh! card across printings
const API_KEY = 'your-api-key';
const res = await fetch(
  'https://api.tcgapi.dev/v1/search?q=ash+blossom&game=yugioh&per_page=5',
  { headers: { 'X-API-Key': API_KEY } }
);
const data = await res.json();

data.data.forEach(card => {
  console.log(`${card.name} — ${card.set_name} [${card.rarity}]`);
  console.log(`  ${card.printing}: $${(card.market_price ?? 0).toFixed(2)}`);
});

Note what this returns: a separate row for each set printing, each with its own rarity and price. That is the distinction that matters for Yu-Gi-Oh!. To get every printing of one card with its 24h/7d/30d changes, call /v1/cards/{id}/prices, which returns an array of price rows.

Feature Comparison

Card Data & Search

• YGOPRODeck — Excellent. Full card text, ATK/DEF, archetypes, fuzzy search
• Konami DB — Authoritative but not machine-readable
• TCG API — Pricing-focused. Search by name, set, rarity, and price

Card Images

• YGOPRODeck — Hosted, free, multiple sizes
• Konami DB — Available but scraping-only
• TCG API — Links to TCGPlayer product pages

Banlist

• YGOPRODeck — TCG, OCG, and GOAT formats
• Konami DB — Official source, published first
• TCG API — Not covered

Pricing

• YGOPRODeck — Sparse, often stale, no history
• Konami DB — None
• TCG API — Daily market prices per printing, with 24h/7d/30d changes and full history

Multi-Game Support

• YGOPRODeck — Yu-Gi-Oh! only
• Konami DB — Yu-Gi-Oh! only
• TCG API — 54 games (Pokemon, Magic, One Piece, Lorcana, etc.)

When to Use Each

Use YGOPRODeck when you need card text, images, archetypes, or banlist status. For a deck builder or card search tool, it is the right default and it is free.

Use TCG API when money is part of your product — collection valuation, price alerts, store pricing, reprint tracking, or anything that needs to know what a specific printing is actually worth today.

Use both together. This is the setup most Yu-Gi-Oh! developers land on: YGOPRODeck for card identity, text, and images, TCG API for what each printing costs. They complement each other cleanly, and neither duplicates the other’s strengths.

Example: Finding Reprint Crashes

Because Yu-Gi-Oh! reprints so aggressively, one of the most useful things you can build is a watchlist for cards that just dropped hard. The price movers endpoint does this in one call:

const API_KEY = 'your-api-key';

async function findCrashes() {
  const res = await fetch(
    'https://api.tcgapi.dev/v1/prices/top-movers?game=yugioh&direction=down&period=7d&limit=20',
    { headers: { 'X-API-Key': API_KEY } }
  );
  const data = await res.json();

  console.log('Biggest 7-day drops in Yu-Gi-Oh!:\n');
  data.data.forEach((card, i) => {
    console.log(`${i + 1}. ${card.name} (${card.set_name}) — ${card.price_change}%`);
  });
}

findCrashes();

Run that weekly and you have a reprint-impact feed with no scraping and no manual tracking.

Getting Started

For a deeper dive:

• Quickstart Guide — Make your first API call in 2 minutes
• Search API Reference — Full-text search with filters
• Price Data — Price endpoints and movers
• Yu-Gi-Oh! on TCG API — All 618 sets and card data
• One Piece API Guide — OPTCG API, API TCG, and the One Piece landscape
• Trading Card Game APIs Compared — Every major TCG API side by side

Ready to add pricing to your Yu-Gi-Oh! project? Sign up for a free TCG API key and follow the quickstart guide. The free tier gives you 100 requests per day, and paid plans start at $9.99/month.

Questions about choosing the right API? Join us on Discord — we’re happy to help you figure out the best stack for your project.