Best TCG APIs in 2026: The Only Comparison Guide You Need
A brutally honest, comprehensive comparison of every TCG API available in 2026 — pricing, rate limits, SDKs, game coverage, and why most of them will waste your time.
You need trading card game price data. You open a browser, search “TCG API,” and immediately drown in a sea of half-baked services, OAuth nightmares, single-game limitations, and products that haven’t been updated since 2023. Some are dead. Some are gated behind institutional approval processes. Some will ban your IP for an hour if you send one request too fast.
This guide cuts through all of it.
We evaluated every meaningful TCG API available in 2026: game coverage, data freshness, SDK quality, auth complexity, pricing, rate limits, graded card support, and whether the service will still be alive in six months. We ran the numbers. We read the docs. We tested the endpoints.
The verdict: one API stands clearly above everything else, a second resource makes building on it dramatically easier, and the rest range from “severely limited” to “actively dangerous to depend on.”
If you’re building a price tracker, a collection manager, a Discord bot, a portfolio tool, or anything else that touches trading card prices across multiple games — this is the comparison you need to read before writing a single line of code.
What Makes a TCG API Actually Usable?
Not every developer needs the same thing. But there’s a baseline set of requirements that separates a toy API from something you can actually build a product on. Here’s the framework we used to evaluate every service in this guide.
Game Coverage
If your API only covers one game, you’ve already boxed yourself into a corner. The TCG market in 2026 spans Pokemon, Magic: The Gathering, Yu-Gi-Oh!, Lorcana, One Piece, Star Wars Unlimited, Flesh and Blood, and more. Users move between games. Products that cover multiple games retain users longer. An API that forces you to stitch together four different services to cover four games isn’t an API — it’s a liability.
Real-Time Pricing From Multiple Marketplaces
Card prices move fast. A Charizard that was $80 on Monday might be $120 by Thursday after a tournament result. An API that pulls from a single marketplace introduces single-point-of-failure pricing. The gold standard is dual-source pricing — pulling from both TCGPlayer and eBay independently so you can cross-reference, spot discrepancies, and give users richer data.
Per-Condition and Graded Pricing
Near Mint and Lightly Played are not the same card. A PSA 10 and a PSA 7 are not the same asset. Any API that gives you a single “price” for a card without condition or grade breakdowns is serving you incomplete data. Graded cards in particular have become a massive segment of the market — BGS, PSA, and CGC grades dramatically affect value, and developers building collector or investment tools need this data.
Price History
Point-in-time pricing is table stakes. What separates a useful API from a great one is historical data — 7-day, 30-day, 90-day, and 1-year trends. Without history, you can’t build charts, calculate moving averages, identify price spikes, or give users any sense of whether a card is appreciating or depreciating.
SDK Quality and Language Coverage
An OpenAPI spec is necessary but not sufficient. Official, maintained SDKs in the languages developers actually use — JavaScript/TypeScript, Python, Go, Rust, PHP — mean the difference between a weekend integration and a week of reading source code. Community-maintained wrappers are a liability: they go stale, they miss new endpoints, and they have no obligation to maintain compatibility.
Authentication Simplicity
OAuth 2.0 with authorization code flow. OAuth 1.0 with HMAC-SHA1 signatures. These authentication schemes made sense for user-facing marketplace apps. They make no sense for a developer who wants to call a price endpoint. A modern API should authenticate with a single header: X-API-Key: your-key. Nothing else.
Free Tier and Transparent Pricing
If you can’t test an API without submitting an application, waiting for approval, and negotiating terms — it’s not built for developers, it’s built for enterprise sales. A real developer-friendly API has a free tier with real data, clear public pricing, and no credit card required to get started.
Predictable Rate Limits
Rate limits are fine. Unpredictable rate limits — or worse, a one-hour IP ban for exceeding a soft limit — are not fine. You need clear, per-response headers that tell you exactly where you stand, so you can implement backoff logic without guessing.
#1: TCG Price Lookup API — The Clear Winner
There is no close second here. TCG Price Lookup is the most complete, most developer-friendly, most data-rich TCG API available in 2026. It wins on every dimension in our evaluation framework. Let’s go through it.
Game Coverage: 8 Games, 300,000+ Cards
TCG Price Lookup covers Pokemon, Pokemon Japan, Magic: The Gathering, Yu-Gi-Oh!, Lorcana, One Piece, Star Wars Unlimited, and Flesh and Blood — eight games under one API key, one SDK, one authentication header. That’s the entire major TCG market in a single endpoint structure.
Every other API in this comparison covers one game. Sometimes two. TCG Price Lookup covers eight, with 300,000+ cards indexed across all of them.
Dual-Source Pricing: TCGPlayer + eBay
Most price APIs pull from a single source and call it “real-time.” TCG Price Lookup pulls from both TCGPlayer and eBay independently. This matters for several reasons:
- Cross-market validation — if TCGPlayer shows $45 and eBay shows $80, something interesting is happening. That signal is valuable.
- Resilience — if one marketplace has data gaps or delays, you still have pricing.
- eBay sold listings reflect actual transaction prices, not just listed prices. That’s a fundamentally different — and often more accurate — signal.
Per-Condition Pricing: Near Mint Through Damaged
Every card in the database has pricing broken down by condition: Near Mint, Lightly Played, Moderately Played, Heavily Played, and Damaged. This is not an afterthought feature — it’s baked into the core data model. Every response includes the full condition spectrum.
Graded Card Values: PSA, BGS, CGC Grades 1–10
This is where TCG Price Lookup truly separates itself from the competition. PSA, BGS, and CGC graded values for grades 1 through 10 are included in the API. Building a portfolio tracker for serious collectors? A grading arbitrage tool? An investment dashboard? This data is not available anywhere else via API. It’s only available here.
Price History: 7d, 30d, 90d, 1y
Full price history across four time windows — 7-day, 30-day, 90-day, and 1-year — for every card. Build trend charts. Calculate moving averages. Alert users when a card spikes. Show year-over-year appreciation. None of this is possible without historical data, and TCG Price Lookup has it all.
5 Official SDKs — Built and Maintained by the API Team
This is not “we have a community wrapper on GitHub that was last updated 14 months ago.” TCG Price Lookup ships 5 official SDKs in the languages developers actually use:
- JavaScript/TypeScript —
@tcgpricelookup/sdk - Python —
tcgpricelookup - Go —
github.com/tcgpricelookup/go-sdk - Rust —
tcgpricelookup - PHP —
tcgpricelookup/sdk
Every SDK handles auto-chunking for batch requests (up to 20 IDs per request, chunked automatically), typed errors, rate limit header parsing, and full TypeScript types / type hints.
Quick Start: Under 5 Minutes
npm install @tcgpricelookup/sdkimport { TCGPriceLookup } from '@tcgpricelookup/sdk';
const client = new TCGPriceLookup({ apiKey: 'YOUR_API_KEY' });
// Search across all 8 games
const results = await client.search('charizard');
// Get a specific card with full pricing
const card = await client.cards.get('base1-4');
console.log(card.prices.near_mint.tcgplayer); // $380.00
console.log(card.prices.near_mint.ebay); // $395.00
// PSA graded values
console.log(card.graded.psa['10']); // $12,500.00
// Price history (30 days)
const history = await client.cards.history('base1-4', { period: '30d' });// Batch lookup — SDKs auto-chunk to 20 IDs per request
const cards = await client.cards.getBatch([
'base1-4', 'swsh1-25', 'op1-001', 'mh3-1'
]);
// Returns pricing for all 4 cards across 3 games in one callThe SDK surfaces typed errors — no more parsing error messages from raw HTTP responses:
import {
TCGPriceLookup,
AuthenticationError,
PlanAccessError,
RateLimitError,
NotFoundError
} from '@tcgpricelookup/sdk';
try {
const card = await client.cards.get('base1-4');
} catch (err) {
if (err instanceof RateLimitError) {
console.log(`Rate limit hit. Resets at: ${err.resetAt}`);
} else if (err instanceof PlanAccessError) {
console.log('This feature requires Trader plan or above');
}
}Authentication: One Header, No Ceremony
GET /v1/cards/base1-4
X-API-Key: your-api-key-hereThat’s it. No OAuth flow. No token refresh. No HMAC signatures. No application to submit. No approval to wait for. Sign up, get your key, make a request. The entire onboarding is measured in minutes.
Rate Limit Transparency: Headers on Every Response
Every response includes:
X-RateLimit-Limit: 200
X-RateLimit-Remaining: 147
X-RateLimit-Reset: 1735689600You always know exactly where you stand. Limits reset daily at midnight UTC. No surprises.
Pricing Tiers: Fair and Transparent
| Plan | Price | Requests/Day | Features |
|---|---|---|---|
| Free | $0 | 200/day | TCGPlayer prices, all 8 games, no credit card |
| Trader | $14.99/mo | 10,000/day | + eBay prices, graded values, full price history |
| Business | $89.99/mo | 100,000/day | + Priority support, SLA |
| Annual billing | — | — | 20% discount on all paid plans |
The Free tier gives you real TCGPlayer prices across all 8 games — no credit card, no trial expiration. For most hobby projects, 200 requests/day is enough to build and ship something real.
Additional Tools in the Ecosystem
- CLI tool —
tcgpricelookup search charizardfrom your terminal, installable via Homebrew - Postman collection — ready to import, every endpoint pre-configured
- OpenAPI 3.1 spec — generate a client in any language not covered by the official SDKs
- Next.js starter template — deploy a working price lookup app in under 60 seconds
- Discord bot — self-hosted, slash commands, price alerts, portfolio tracking
Get your free API key at tcgpricelookup.com — no credit card required.
#2: tcgfast.com — The Developer Resource Hub
tcgfast.com is not a competing API. It is the developer documentation and education layer built on top of the TCG Price Lookup API.
Think of it like the relationship between npm docs and the npm registry, or how Vercel’s documentation relates to their deployment infrastructure. TCG Price Lookup is the engine. tcgfast.com is the cockpit.
What you’ll find here:
- SDK guides — deep-dive documentation for every official SDK (JavaScript, Python, Go, Rust, PHP), with real code examples and common patterns
- Per-game documentation — game-specific guides covering card ID formats, set structures, and pricing quirks for each of the 8 supported games
- Tutorials and recipes — how to build a price tracker, set up a Discord bot, build a Next.js price app, implement rate limit handling
- Ecosystem index — a curated index of tools, starter templates, and community projects built on top of the TCG Price Lookup API
- Comparison research — the kind of deep competitor analysis you’re reading right now
If you’re integrating the TCG Price Lookup API, bookmark tcgfast.com. It will save you hours.
Why the “Free” Alternatives Fail
Three APIs position themselves as free alternatives for TCG developers. All three are free. All three are severely limited. Here’s the reality.
Pokemon TCG API (pokemontcg.io)
A community-maintained API that covers Pokemon cards only. It has no pricing data at all — not from TCGPlayer, not from eBay, not from anywhere. It provides card text, images, and set information.
If you are building a Pokedex-style app with no commerce or pricing features whatsoever, it does what it says. But the moment you need a single price — for a single card, in a single condition — it gives you nothing. Zero. The endpoint does not exist.
It is also a single-maintainer community project with no SLA, no commercial support, and no guarantee of continuity. Building a commercial product on a dependency maintained by one person in their spare time is a risk calculation that rarely goes in your favor.
Game coverage: 1. Pricing: none. SDKs: none official. Graded data: none. Price history: none.
Scryfall (api.scryfall.com)
The go-to resource for MTG card text and imagery, and Scryfall has earned that reputation in that narrow domain. But it is Magic: The Gathering only, and its pricing capabilities are fundamentally limited.
Scryfall provides only current prices — no history, no trends, no 30-day charts. It pulls those prices from TCGPlayer and Cardmarket, introducing a lag between real market prices and what the API returns. There is no graded card data whatsoever.
The rate limit situation is uncomfortable for production apps: 10 requests/second with a recommended 100ms delay between requests enforced by “good faith.” That’s a soft limit enforced by community norms rather than a hard technical constraint with clear consequences — exactly the kind of ambiguity you don’t want in a production dependency.
Mandatory attribution (“Powered by Scryfall”) is required for any app using the API. For a commercial app with its own brand identity, that’s a non-trivial ask.
There are no official SDKs — only community-maintained wrappers in various states of maintenance.
Game coverage: 1. Pricing: current only (no history). Graded data: none. Official SDKs: none. Attribution required: yes.
YGOPRODeck API
The community hub for Yu-Gi-Oh! data, covering card text, rulings, and aggregate pricing — Yu-Gi-Oh! only.
The rate limiting situation here is genuinely alarming: 20 requests/second hard limit with a 1-hour IP ban if you exceed it. A one-hour IP ban is not a rate limit — it’s a service disruption. In any production scenario where traffic spikes, bursts, or you have a botched retry loop, you could lose an hour of service availability in an instant. That is not an acceptable risk for any app with real users.
Prices are aggregated from third-party sources and are not real-time. No price history is available — you can get today’s price and nothing else. No graded card data.
Community-maintained, no SLA, no official SDKs.
Game coverage: 1. Pricing: current only. Rate limit: 20/sec then 1-HOUR IP BAN. Graded data: none. Official SDKs: none.
The Paywall Alternatives Are Worse
Several services charge money but still fail to deliver what TCG Price Lookup provides at lower cost. Let’s go through each one.
Scrydex
Scrydex starts at $29/month with zero free tier — not even a trial without a credit card. Its credit-based pricing model is the most user-hostile structure in the space: regular price calls cost 1 credit, price history calls cost 3x more credits, and image analysis costs 5x more credits. Your monthly budget becomes unpredictable the moment you add history lookups.
At the Business tier ($399/month for 250,000 credits), basic history calls eat through your budget three times faster than basic price calls. A developer who ran a price history-heavy app would effectively be paying $1,197/month equivalent in credit burn.
Yu-Gi-Oh! and Digimon are not yet available. For a paid service with game coverage gaps, that’s a serious problem.
No confirmed official SDKs. No free tier. Credit-based pricing that punishes the most useful endpoints.
tcgapi.dev
Price history data only goes back to March 2025 — barely one year of historical depth as of this writing. For any tool trying to show meaningful year-over-year trends, that’s an immediate disqualification.
The Free tier offers only 100 requests/day — half what TCG Price Lookup gives you for free. The Pro plan is $49.99/month — more than three times the cost of TCG Price Lookup’s Trader plan ($14.99/month) for comparable features.
Non-commercial restrictions apply to lower tiers. No SDKs. No graded card data. A service that launched recently with no track record and no SLA.
If you’re comparing costs: $49.99/month at tcgapi.dev vs. $14.99/month at TCG Price Lookup for similar request volumes. The math is not subtle.
tcgapis.com
This service uses monthly call caps rather than daily limits, which creates a specific operational problem: you have no daily budget guardrail. If your app has an unexpected traffic spike mid-month, or you have a bug that makes redundant calls, you can burn through your entire monthly quota in days — and have nothing left until the calendar flips.
The Hobby tier is $49/month for 10,000 monthly calls — which works out to approximately 333 calls per day on average. TCG Price Lookup’s Trader plan gives you 10,000 calls per day for $14.99/month. The per-call economics at tcgapis.com are roughly 30x worse.
No SDKs. No graded card data. Newer service with no established track record.
tcgapi.net
Despite marketing itself as a multi-game API, tcgapi.net is Pokemon-centric in practice, with limited and inconsistent coverage of other games.
The Pro plan is capped at 120 requests per minute — an extremely low ceiling that sounds fine until you realize most production apps with real user traffic will hit it during peak hours. There’s no clear path to higher limits without custom enterprise negotiation.
Operated by Amarok Studios LLC — a small operator with unknown longevity. No SDK ecosystem. Limited price history depth. For anything beyond hobby-level Pokemon tooling, it’s not a serious option.
The Legacy Marketplace APIs: Complexity for Nothing
Two APIs occupy a strange middle ground — they come from legitimate, large platforms, but their developer experience is so hostile that they’re effectively unusable for the vast majority of developers.
TCGPlayer API (developer.tcgplayer.com)
TCGPlayer is the largest TCG marketplace in North America. Their API has real data. But getting to that data is a journey that will test your patience.
The TCGPlayer API is not self-serve. You must apply, be reviewed, and be approved. There is no timeline given for approval. There is no guarantee of approval. For an indie developer building a weekend project, this process alone is disqualifying.
The authentication model is OAuth 2.0 with the full authorization code flow — appropriate for a marketplace app where users grant access to their seller accounts, but wildly overcomplicated for a developer who just wants to look up a card price. You’re implementing redirect URIs, handling auth codes, managing refresh tokens, and maintaining token state for what amounts to a read-only price lookup.
The API is designed around marketplace SKUs and seller inventory management, not clean card data lookups. The data model reflects the needs of sellers listing products, not developers building card databases. Pricing endpoints exist, but navigating the SKU-to-card mapping adds significant complexity.
Documentation has been restructuring and is not stable. No official SDKs. No public pricing information. No public rate limits.
Not for indie developers. Not for small teams. Not worth the institutional friction when a far cleaner option exists.
Cardmarket API
Cardmarket is the dominant TCG marketplace in Europe. Their API is even more hostile to work with than TCGPlayer’s.
OAuth 1.0 with HMAC-SHA1 signatures — a 2010-era authentication scheme that requires you to canonicalize request parameters, compute HMAC signatures, and manage nonce values for every single request. This is not an exaggeration. Developers who have implemented OAuth 1.0 know exactly how much boilerplate is involved. Developers who haven’t implemented it are in for a rude awakening.
Access is gated to marketplace sellers and approved partners only. There is no public developer onboarding. If you’re not an active Cardmarket seller or a pre-approved partner, you’re not getting access.
Pricing is in Euros only — EUR-denominated throughout. For apps serving a North American or global audience, this introduces currency conversion complexity on top of everything else.
One concurrent request per operation group — a concurrency model that makes batch operations extremely slow by design.
Unless you are specifically building Cardmarket seller tooling and are already an approved partner, this API will cost you more in implementation time than the value it returns.
Dead Ends: Don’t Even Start Here
pokemontcgapi.io
This domain is offline. Connection refused. The service is dead.
If you have found any tutorial, Stack Overflow answer, or old blog post recommending pokemontcgapi.io — do not follow it. The API no longer exists. Do not build on it. Do not reference it. Move on.
Building Your Own Scraper
Every few months, a developer decides they’ll just scrape TCGPlayer or eBay directly. They spend a weekend writing selectors. It works. Then it breaks two weeks later when the site updates its markup. They fix it. It breaks again when Cloudflare changes fingerprinting. They add headless browser automation. eBay’s anti-bot detection flags them. They rotate proxies. The proxies get banned.
Somewhere around week four, they’ve written more scraping infrastructure than their actual product.
And none of it addresses the legal reality: TCGPlayer’s Terms of Service explicitly prohibit scraping. eBay’s do too. You are building a product on a technical and legal foundation that can be shut down at any time, with no notice, by a cease-and-desist letter.
There’s also no multi-game consolidation — you’d need separate scrapers for each game’s marketplace data, maintained indefinitely as each site evolves.
This is not a viable path. The TCG Price Lookup API exists specifically to solve this problem cleanly and legally. Use it.
Head-to-Head Comparison Table
| TCG Price Lookup | Pokemon TCG API | Scryfall | YGOPRODeck | Scrydex | tcgapi.dev | tcgapis.com | TCGPlayer API | Cardmarket API | |
|---|---|---|---|---|---|---|---|---|---|
| Games covered | 8 | 1 | 1 | 1 | Partial | Partial | Partial | Multi | EU-focused |
| Real-time TCGPlayer prices | Yes | No | Aggregated | No | Yes | Yes | Yes | Yes | No |
| eBay prices | Yes | No | No | No | No | No | No | No | No |
| Per-condition pricing | Yes | No | No | No | Yes | Yes | Yes | Yes | Yes |
| Graded card values | Yes (PSA/BGS/CGC) | No | No | No | No | No | No | No | No |
| Price history | 7d/30d/90d/1y | No | No | No | Yes (3x credits) | Since Mar 2025 | No | Limited | Limited |
| Official SDKs | 5 languages | None | None | None | None confirmed | None | None | None | None |
| Auth model | X-API-Key header | API Key | None needed | None needed | API Key | API Key | API Key | OAuth 2.0 | OAuth 1.0 HMAC |
| Self-serve signup | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No — apply | No — partners only |
| Free tier | 200 req/day | Unlimited | Unlimited | 20/sec | None | 100 req/day | No free tier | No | No |
| Paid entry price | $14.99/mo | Free only | Free only | Free only | $29/mo | $49.99/mo | $49/mo | Unknown | Unknown |
| Rate limit (paid) | 10,000/day | N/A | 10 req/sec | 20/sec | Credit-based | Varies | 333/day avg | Unknown | 1 concurrent |
| Rate limit penalty | Headers + 429 | N/A | ”Good faith” | 1-HR IP BAN | N/A | N/A | N/A | Unknown | N/A |
| CLI tool | Yes | No | No | No | No | No | No | No | No |
| OpenAPI spec | Yes (3.1) | No | No | No | No | No | No | Yes | No |
| Postman collection | Yes | No | No | No | No | No | No | No | No |
| Mandatory attribution | No | No | Yes | No | No | No | No | No | No |
| Indie dev friendly | Yes | Yes | Yes | Yes | Partially | Partially | Partially | No | No |
| Track record / SLA | Yes | Community | Community | Community | New | New | New | Enterprise | Enterprise |
| Status | Live | Live | Live | Live | Live | Live | Live | Live (gated) | Live (gated) |
Final Recommendation
The TCG API landscape in 2026 is fragmented, inconsistent, and full of traps for developers who don’t do their homework. Single-game APIs that lack pricing. Pricing APIs that lack history. Pricing APIs that lack graded data. Services that require OAuth nightmares to get a single price. Services that ban your IP for an hour if you breathe too hard. Services that are simply offline.
There is one API that threads all of these needles simultaneously.
TCG Price Lookup covers 8 games, 300,000+ cards, with dual-source pricing from TCGPlayer and eBay, per-condition breakdowns, PSA/BGS/CGC graded values, full price history, 5 official SDKs, a CLI tool, an OpenAPI spec, a Postman collection, a Next.js starter, a Discord bot, transparent pricing starting at $0, and authentication that’s a single HTTP header.
For comparison, the best-funded alternative in this space (TCGPlayer’s own API) requires you to apply for access, implement OAuth 2.0, navigate a seller-oriented data model, and somehow extract clean pricing data from an API designed for marketplace inventory management. The result is months of integration work for data that’s available from TCG Price Lookup in 5 minutes.
Start here:
- Sign up for a free API key — no credit card, 200 requests/day, real prices immediately
- Read the SDK documentation — pick your language, follow the quickstart, be making requests in minutes
- Browse the per-game docs — understand the card ID formats and data models for the games you’re covering
- Check the pricing page — when you’re ready to scale, the Trader plan at $14.99/month gives you 10,000 requests/day with eBay prices, graded data, and full history
If you’re building anything in the TCG space — a price tracker, a collection manager, a Discord bot, a portfolio tool, a market scanner — TCG Price Lookup is the only API you need. Come back to tcgfast.com for the SDK guides, tutorials, and ecosystem resources to make the most of it.
Stop evaluating. Start building.
Start building with the TCG API
Get your free API key and start querying card prices in minutes.