A legjobb TCG API-k 2026-ban: Fejlesztői útmutató gyűjtői kártyajáték adatokhoz

A gyűjtői kártyajáték piac 2026-ban tovább bővül, és ezzel párhuzamosan egyre több fejlesztő keres megbízható API-t az alkalmazásaik mögé. Legyen szó árkövetőről, portfólió-kezelőről, Discord botról vagy komplex kereskedési platformról — a megfelelő TCG API kiválasztása alapvetően meghatározza a projekt sikerét.

Ebben az útmutatóban áttekintjük a 2026-ban elérhető legjobb TCG API-kat, megvizsgáljuk az erősségeiket és korlátaikat, majd konkrét ajánlásokat adunk különböző felhasználási esetekhez.

Mi az a TCG API és mire jó?

A TCG API (Trading Card Game Application Programming Interface) egy webszolgáltatás, amely programozott hozzáférést biztosít gyűjtői kártyajáték adatokhoz. A legjobb TCG API-k a következőket biztosítják:

Valós idejű piaci árak — TCGPlayer, eBay és más platformok aktuális adatai
Kártyametaadatok — név, ritkaság, készletinformációk, kártyaszám
Állapot szerinti árak — Near Mint, Lightly Played, stb.
Besorolt kártyaárak — PSA, BGS, CGC beminősítési adatok
Ártörténet — historikus adatok trendek elemzéséhez
Több játék támogatása — Pokémon, MTG, Yu-Gi-Oh! és más TCG-k

A 2026-os TCG API piac áttekintése

A piac 2026-ra jelentősen érett. Néhány év alatt megszűnt az a helyzet, hogy fejlesztőknek külön API-t kellett integrálni minden egyes játékhoz. Az aggregált megoldások térnyerése lehetővé teszi, hogy egyetlen kulccsal és egységes interfészen érhessenek el adatokat több TCG-ből.

Fő szereplők 2026-ban

TCG Price Lookup — Az egyik legszélesebb körű aggregált megoldás, amely 8 játékot fed le egyetlen API-n keresztül. 300 000+ indexelt kártyával, valós idejű TCGPlayer és eBay árakkal, besorolt adatokkal és 5 különböző programozási nyelvhez elérhető SDK-val ez az egyik legteljesebb megoldás fejlesztőknek.

Scryfall API — Kizárólag Magic: The Gathering-re fókuszáló, kiváló minőségű, ingyenes API. Kiváló kártyametaadatokkal rendelkezik, de az árak csak részlegesen elérhetők (TCGPlayer integráción keresztül), és más TCG-ket nem támogat.

pokemontcg.io — A Pokémon TCG dedikált API-ja. Jó kártyametaadatokkal bír, de hiányzik belőle a valós idejű áradata, ami limitálja a kereskedelmi felhasználhatóságát.

TCGPlayer API — Közvetlen hozzáférés a TCGPlayer platformhoz. Jó áradatokkal rendelkezik, de a hozzáférés kérelmes folyamaton keresztül történik, és főként TCGPlayer-listázásokra korlátozódik.

TCG Price Lookup API részletes áttekintése

Áttekintés

A TCG Price Lookup egy komprehenzív aggregált API, amely 8 TCG-t fed le egyetlen egységes interfészen. A fejlesztők számára ez azt jelenti: egy API-kulcs, egy integrációs munka, minden játék.

Támogatott játékok:

Pokémon TCG (angol és japán)
Magic: The Gathering
Yu-Gi-Oh!
Disney Lorcana
One Piece kártyajáték
Star Wars: Unlimited
Flesh and Blood

Főbb funkciók:

Valós idejű árak — Az API folyamatosan frissíti az árakat a TCGPlayer aktív listázásaiból és az eBay lezárt aukciói alapján. Ez azt jelenti, hogy mind a listaárak, mind a tényleges tranzakciós árak elérhetők.

Állapot szerinti adatok — Minden kártyához elérhető Near Mint, Lightly Played, Moderately Played, Heavily Played és Damaged állapot szerinti árazás. Ez kritikus a valós kereskedési döntésekhez.

Besorolt kártyaárak — PSA (1–10. fokozat), BGS (7–10, 9.5, 10 Black Label) és CGC (1–10. fokozat) besorolt árak eBay értékesítési adatok alapján. Ez a funkció Trader csomaghoz kötött.

Ártörténet — 90 napos historikus adatok, amelyek lehetővé teszik a trendek elemzését, a szezonális változások azonosítását és a vételi/eladási pontok meghatározását.

Pricing struktúra

Az ingyenes csomag napi 200 kéréssel alkalmas fejlesztésre, prototípus-készítésre és kisebb hobbi projektekre. A Trader csomag ($14.99/hó) napi 10 000 kéréssel, eBay árakkal, besorolt adatokkal és ártörténettel a legtöbb kereskedelmi alkalmazáshoz elegendő. A Business csomag ($89.99/hó) napi 100 000 kéréssel a nagy forgalmú platformoknak szól.

SDK és integráció

Az egyik legfontosabb előnye az SDK-ökoszisztéma. Jelenleg öt nyelven érhető el hivatalos, karbantartott SDK:

npm install @tcgpricelookup/sdk     # JavaScript/TypeScript
pip install tcglookup               # Python
go get github.com/TCG-Price-Lookup/tcglookup-go  # Go
cargo add tcglookup                 # Rust
composer require tcg-price-lookup/tcglookup  # PHP

Minden SDK egységes interfészt biztosít, és automatikusan kezeli a hitelesítést, a rate limiteket és a hibákat.

Kód példa: Első integráció

Nézzük meg, hogyan néz ki egy egyszerű árkövetés JavaScriptben:

import { TcgLookupClient } from '@tcgpricelookup/sdk';

const tcg = new TcgLookupClient({ 
  apiKey: process.env.TCG_API_KEY 
});

// Pokémon kártyák keresése
const charizards = await tcg.cards.search({
  name: 'Charizard',
  game: 'pokemon',
  limit: 10
});

for (const card of charizards.data) {
  console.log(`${card.name} (${card.set.name})`);
  console.log(`  NM ár: $${card.prices.nearMint.market}`);
  console.log(`  LP ár: $${card.prices.lightlyPlayed?.market}`);
}

Ugyanez a kód minimális módosítással működik más játékoknál is — csak a game paramétert kell módosítani.

Scryfall API: A Magic-specifikus alternatíva

A Scryfall API a Magic: The Gathering legjobb ingyenes adatforrása. Ha kizárólag MTG-vel dolgozol, és nem szükséges az áradat, a Scryfall kiváló választás.

Erősségek:

Ingyenes és korlát nélküli (józan felhasználás esetén)
Kivételes kártyametaadatok (Oracle szöveg, ruling, kiadás adatok)
Hatékony keresési szintaxis (a Scryfall search language)
Magas minőségű kártyaképek

Korlátok:

Csak MTG-t támogat
Valós idejű áradata korlátozott
Nincs besorolt ár
Nincs ártörténet
Nem alkalmas kereskedelmi alkalmazásokhoz áradat nélkül

Ha MTG-specifikus alkalmazást fejlesztesz, de szükséged van áradatokra, érdemes kombinálni a Scryfallet a TCG Price Lookup API-val: metaadatokhoz Scryfall, árakhoz TCG Price Lookup.

pokemontcg.io: Pokémon-specifikus megoldás

A pokemontcg.io jól dokumentált API Pokémon TCG adatokhoz. Ingyenes és alkalmas kártyametaadat lekérésekre.

Erősségek:

Ingyenes alap hozzáféréssel
Jó Pokémon-specifikus adatok (HP, típus, gyengeség stb.)
Aktív közösség és SDK-k

Korlátok:

Csak Pokémon TCG-t támogat
Nincs valós idejű áradata
Nem alkalmas árkövetési vagy kereskedési alkalmazásokhoz
Más TCG-k lekéréséhez külön API szükséges

Melyik API-t válasszuk?

Ha több TCG-t szeretnél támogatni

Válassz TCG Price Lookup-ot. Egyetlen API-kulccsal eléred a Pokémon, MTG, Yu-Gi-Oh!, Lorcana, One Piece, Star Wars Unlimited és Flesh and Blood adatait. Az egységes interfész rengeteg fejlesztési időt takarít meg, különösen ha a jövőben más játékokat is hozzá kell adni.

Ha csak MTG metaadatokra van szükséged

Scryfallal kezdj. Az ingyenes, részletes és megbízható. Ha később áradat is kell, integráld a TCG Price Lookup-ot is.

Ha Pokémon-specifikus alkalmazást fejlesztesz áradattal

Válassz TCG Price Lookup-ot. A pokemontcg.io kiváló metaadatokkal bír, de hiányzik az áradata. A TCG Price Lookup-ban megvan minden, ami egy éles Pokémon árkövetőhöz kell.

Ha besorolt kártyaárakra is szükséged van

TCG Price Lookup Trader csomag. Ez az egyetlen API, amely rendszeresen frissített PSA, BGS és CGC besorolt árakat biztosít programozható formában.

Tipikus felhasználási esetek és ajánlások

Portfólió-követő alkalmazás

Egy portfólió-követőnek valós idejű árak, ártörténet és állapot szerinti adatok kellenek.

Ajánlott megoldás: TCG Price Lookup Trader csomag

from tcglookup import TCGLookup

tcg = TCGLookup(api_key='your-key')

# Portfólió értékének kiszámítása
portfolio = [
    {'id': 'pokemon-base1-4', 'condition': 'nearMint', 'quantity': 1},
    {'id': 'mtg-lea-232', 'condition': 'lightlyPlayed', 'quantity': 4},
]

total_value = 0
for item in portfolio:
    card = tcg.cards.get(item['id'])
    price = card.prices[item['condition']]['market']
    total_value += price * item['quantity']

print(f"Portfólió értéke: ${total_value:.2f}")

Discord bot

Egy TCG Discord botnak gyors keresési funkciókra és több játék támogatására van szüksége.

Ajánlott megoldás: TCG Price Lookup ingyenes csomag kisebb közösségeknek, Trader csomag nagyobb forgalomhoz

A nyílt forráskódú Discord bot starter template közvetlenül integrálható a TCG Price Lookup API-val. A /price charizard slash-parancs másodperceken belül visszaadja az aktuális piaci árat, az állapot szerinti értékeket és a 24 órás változást.

Árösszehasonlító oldal

Egy árösszehasonlítónak nagy mennyiségű adatot kell lekérnie és cache-elnie.

Ajánlott megoldás: TCG Price Lookup Business csomag

A kötegelt lekérés (batch endpoint) lehetővé teszi, hogy egyetlen kéréssel 20 kártyát is lekérdezz, ami drámaian csökkenti az API-hívások számát.

// Hatékony: 1 kötegelt kérés 20 kártyához
const cards = await tcg.cards.batch([
  'pokemon-base1-4',
  'pokemon-sv4-006',
  'mtg-lea-232',
  // ... max 20 azonosító
]);

Arbitrázs eszköz

Az arbitrázs eszközöknek valós idejű ártérképet kell építeniük TCGPlayer és eBay között.

Ajánlott megoldás: TCG Price Lookup Trader csomag

Az API mindkét forrásból (TCGPlayer és eBay) biztosít adatokat, ami lehetővé teszi az arbitrázs lehetőségek automatikus azonosítását:

const results = await tcg.cards.search({ name: 'Black Lotus', game: 'mtg' });

for (const card of results.data) {
  const tcgpPrice = card.prices.nearMint.tcgplayer;
  const ebayPrice = card.prices.nearMint.ebay;
  const spread = ((ebayPrice - tcgpPrice) / tcgpPrice * 100).toFixed(1);
  
  if (Math.abs(spread) > 10) {
    console.log(`${card.name}: TCGPlayer $${tcgpPrice}, eBay $${ebayPrice} (${spread}% különbség)`);
  }
}

Legjobb gyakorlatok TCG API integrálásakor

1. Gyorsítótárazás implementálása

A TCG kártyaárak néhány óránként frissülnek, nem másodpercenként. Egy megfelelő cache réteg jelentősen csökkentheti az API-hívások számát és javíthatja az alkalmazás válaszidejét.

class CachedTcgClient {
  constructor(apiKey, cacheTtlMs = 5 * 60 * 1000) {
    this.tcg = new TcgLookupClient({ apiKey });
    this.cache = new Map();
    this.cacheTtlMs = cacheTtlMs;
  }

  async getCard(id) {
    const cached = this.cache.get(id);
    if (cached && Date.now() - cached.timestamp < this.cacheTtlMs) {
      return cached.data;
    }
    const data = await this.tcg.cards.get(id);
    this.cache.set(id, { data, timestamp: Date.now() });
    return data;
  }
}

2. Hibakezelés és újrapróbálkozás

A rate limit hibákat kecsesen kell kezelni, különösen ha az alkalmazás nagyobb forgalmat generál:

async function fetchWithBackoff(fn, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429) {
        const retryAfter = parseInt(error.headers['retry-after'] || '60');
        await new Promise(r => setTimeout(r, retryAfter * 1000));
      } else if (attempt === maxRetries - 1) {
        throw error;
      }
    }
  }
}

3. Környezeti változók használata

Soha ne keményíts be API-kulcsokat a kódba. Mindig környezeti változókat használj:

// Helyes
const tcg = new TcgLookupClient({ 
  apiKey: process.env.TCG_API_KEY 
});

// Helytelen
const tcg = new TcgLookupClient({ 
  apiKey: 'tpl_live_xxxxxxxxxxxx' // NE csináld ezt!
});

4. Batch lekérések maximalizálása

Ha több kártyát kell lekérned, mindig a batch endpointot használd (Trader csomag):

# Hatékony
card_ids = ['pokemon-base1-4', 'pokemon-base1-10', 'mtg-lea-232']
cards = tcg.cards.batch(card_ids)

# Nem hatékony
cards = [tcg.cards.get(id) for id in card_ids]  # 3 API-hívás

Jövőbeli trendek: TCG API-k 2026-ban és azon túl

A TCG API piac 2026-ban tovább fejlődik. Néhány fontosabb trend:

Több játék aggregáció — Az igény az egységes, többjátékos API-k iránt folyamatosan nő. A fejlesztők egyszerűbbé szeretnék tenni az integrációt, és nem akarnak minden új TCG-hez új API-t beépíteni.

Besorolt kártyapiac növekedése — A PSA, BGS és CGC besorolt kártyák piaca exponenciálisan nő. A besorolt árak API-n keresztüli elérhetősége egyre fontosabb.

Valós idejű adatok iránti igény — Az árak egyre gyorsabban változnak a piaci mozgásokkal. Az API-k egyre inkább a sub-óra szintű frissítések felé mozdulnak.

Japán piac integrációja — A japán Pokémon és One Piece piac ár-előrejelzői az angol piacon egyre fontosabbak. Az API-k, amelyek japán verziókat is fednek, versenyelőnyt biztosítanak.

Összefoglalás

A legjobb TCG API 2026-ban az, amelyik megfelel az alkalmazásod konkrét igényeinek. Íme a gyors összefoglaló:

Felhasználási eset	Ajánlott API
Több TCG támogatása	TCG Price Lookup
Csak MTG metaadat	Scryfall
Pokémon + áradata	TCG Price Lookup
Besorolt kártyaárak	TCG Price Lookup Trader
Nagy léptékű platform	TCG Price Lookup Business
Prototípus / tanulás	TCG Price Lookup Ingyenes

Ha nem tudod, hol kezdj, a TCG Price Lookup ingyenes csomagja az legjobb kiindulópont — bankkártya nélkül, 200 kérés/nap mennyiséggel kipróbálhatod az összes funkciót, és hozzáérhetsz mind a 8 támogatott játék 300 000+ kártyájához.

Hasznos linkek: