Trading card price data APIs

If you're serious about trading TCGs and tracking thousands of cards, I'd separate this into two decisions: the best pricing API for your data and the best app for monitoring your portfolio. They're not necessarily the same product.

One important distinction: most TCG pricing services provide frequently refreshed market estimates, not true tick-by-tick prices. For trading, you'll want to know the exact printing, foil variant, condition, language, and recent sales activity—not just the card's headline price.

My top picks

• 

1. TCG API

(Best overall API)

Best for multi-game portfolios and automated price tracking

Covers dozens of TCGs, with market prices, bulk resolution, price history, and price-change analytics. Its published Pro plan is $49.99/month and includes bulk endpoints, per-condition pricing, and commercial-use rights.tcgapi.dev+1

Why I'd start here: it is built for programmatic pricing across a large card catalog, rather than just scanning a collection.

Website and pricing

---

• 

2. JustTCG

Best alternative for condition-specific pricing

Covers Magic, Pokémon, Yu-Gi-Oh!, Lorcana, One Piece, and Digimon. Worth evaluating if you need to price Near Mint versus Lightly Played cards and retain historical data. Published paid plans start at $19/month, with commercial access on paid plans.tickermint.cards+1

Website

---

• 

3. TickerMint

Best for historical trends in supported games

Offers daily price history and historical market data for Pokémon, One Piece, Lorcana, Yu-Gi-Oh!, Riftbound, and Gundam. Its free tier is useful for testing, while commercial API plans start at $49/month. It is not the right choice if you need Magic: The Gathering pricing.tickermint.cards+1

API comparison and pricing

---

• 

4. PriceCharting

Best for bulk price-list downloads and broader collectibles

Useful if you want a downloadable CSV of thousands of items rather than calling an API for every card. Its Legendary subscription includes API access and bulk CSV data; the documented API is limited to current values and doesn't provide historical prices or sales.tickermint.cards+1

API documentation

---

• 

5. Collectr

Best ready-made portfolio app

Tracks collection value across multiple TCGs, supports filters and portfolio views, and is free to start. It's a better starting point if you want to manage your cards without building your own software. It is a portfolio tracker, not my first choice for a custom pricing-data pipeline.www.getcollectr.com+1

Official website

What about TCGplayer's API?

TCGplayer's pricing data has long been a major reference for the North American market, and its API supports market, low, mid, and high prices. However, its current developer documentation says it is not granting new API access. If you don't already have credentials, I wouldn't build a new system around getting them.docs.tcgplayer.com+1

How I'd set up a serious trading operation

If you're tracking thousands of cards and looking for trading opportunities, I'd build around a pricing API rather than rely entirely on a portfolio app.

Your card inventory

Card ID · Set · Variant · Condition · Quantity · Cost basis

Pricing API + local database

Batch updates · Price history · Last-updated timestamps

Portfolio value

Total value, profit/loss, cost basis

Trade signals

Price changes, spread, potential buys

For a few thousand cards, I'd prioritize these capabilities:

• Bulk pricing: update hundreds or thousands of cards efficiently.
• Reliable card matching: distinguish different sets, editions, foils, languages, and conditions.
• Price history: identify trends rather than react to a single price change.
• Liquidity signals: where available, track sales volume and recent completed sales.
• Net trade value: account for selling fees, shipping, and the difference between market value and what you can actually sell a card for.
• Scheduled refreshes: refresh frequently for actively traded cards and less frequently for low-value inventory.

One critical point: don't treat an API's market price as a guaranteed sale price. For trading, recent completed sales and the spread between buying and selling prices can matter more than the headline valuation.

One question so I can narrow this down

Which games are you primarily trading?

1. Which TCGs?

---

2. What's the main use?

Tracking my collection and trades

Finding underpriced cards to flip

Running a store or online inventory

Building my own pricing dashboard or app

---

3. Monthly budget for pricing data

Free only

$20–$60/month

$60–$150/month

$150+/month if the data is worth it

---

4. How often do prices need to update?

Once daily is fine

Every 15–60 minutes

As close to real-time as possible

[Find my best setup]

With those answers, I can narrow this to the best fit for your trading strategy, including whether you need a turnkey app or a pricing pipeline that can scale with thousands of cards.

When you are scaling up to track thousands of cards for serious trading or portfolio management, you need robust options depending on whether you want a developer API to build a custom tool or an out-of-the-box app to manage your inventory.

Top TCG Pricing APIs (For Custom Apps & Automation)

1. TCGplayer Official API
   • Best For: Industry-standard marketplace data.
   • Why it's great: TCGplayer is the de facto North American pricing standard. Their official API gives you direct access to SKU-level conditions, low/mid/high, and Market Price data.
   • Catch: Access to the official developer API requires application approval from TCGplayer and is typically geared toward commercial platforms, integrated stores, or established community projects.
2. TCGAPIs
   • Best For: Rapid deployment and multi-game real-time tracking.
   • Why it's great: Updates hourly, provides low, mid, high, and market values across 80+ TCGs (Pokémon, MTG, Yu-Gi-Oh!, One Piece, Lorcana, etc.), and bypasses the red tape of obtaining an enterprise-level official marketplace handshake just to get rolling.tcgapis.com
3. TCG API (tcgapi.dev)
   • Best For: Trend analysis and market movers.
   • Why it's great: Built specifically with price trackers in mind. It automatically calculates 2 4 h, 7 d , and 3 0 d percentage changes natively in the JSON payload, and features a dedicated top-movers endpoint so you don't have to poll thousands of cards individually.tcgapi.dev
4. JustTCG
   • Best For: Blended volume-weighted retail and online counter data.
   • Why it's great: It blends major online marketplace data with physical local game store point-of-sale systems to give a realistic look at what cards actually transact for, rather than just floating active listings.justtcg.com

Top TCG Portfolio & Tracking Apps (Out-of-the-Box)

If you prefer an application where you can scan barcodes or punch in thousands of cards without writing code:

• TCGplayer App
  • The Verdict: The absolute gold standard for real-time market pricing and scanning singles on the fly. It utilizes the live TCGplayer marketplace backend, making it unmatched for accurate liquidity and current buy/sell targets.
• Collectr
  • The Verdict: Great for visual portfolio tracking and macro-level collection valuation across multiple TCGs. Note: Serious traders often critique it for lagging slightly behind rapid single-card market spikes compared to live marketplace feeds, but it shines as a high-level dashboard.reddit.com
• PriceCharting
  • The Verdict: Excellent if your trading inventory bleeds heavily into graded cards (PSA/BGS/CGC) alongside raw singles, as it aggregates historical auction and sales data across multiple platforms.reddit.com

Are you planning to code your own tracking software using an API, or are you looking for a consumer-facing mobile/desktop app to manage a physical collection?

Yes. I found several viable options, but the best choice depends heavily on whether you mean Pokémon/MTG-style TCGs, sports cards, or both. For a production tool where consistency matters, I’d shortlist these:

1. TCG API — probably my first choice

This is the cleanest match to what you're building if your tool covers Pokémon, MTG, Yu-Gi-Oh!, One Piece, Lorcana, etc.

It currently covers 57 games and 3,966+ sets, with individual printings tracked separately. Its history endpoint provides daily market/low prices and sales information, with historical data beginning in March 2025. Pro/Business plans expose the complete available history and bulk history/set exports.tcgapi.dev

The particularly useful part for your team is the set-oriented API:

• stable set IDs
• set → card relationships
• printing/foil distinctions
• current prices
• historical prices
• sales volume / average sales price
• bulk history
• CSV/JSON set exports

The Pro plan is currently $49.99/month and includes commercial use, full history, bulk endpoints and exports; Business is $99.99/month.tcgapi.dev

Caveat: its historical series only goes back to March 2025, so it isn't appropriate if you need, say, 2010–2024 historical pricing.

2. JustTCG — strong alternative

JustTCG is particularly interesting if commercial licensing and retaining historical data are important.

Its API has stable set IDs and explicit set metadata, and price history can be returned alongside card/variant data. It added a one-year daily history option in April 2026.justtcg.com

Its paid commercial terms explicitly allow things such as:

• displaying prices/history to your users
• deriving your own analytics
• caching/storing price history
• combining the data with other lawful sources

while prohibiting simply reselling the raw feed or building a competing API.justtcg.com

That's a meaningful advantage for a product team: the licensing model is clearly oriented toward building applications on top of the data.

3. RareBit API documentation — worth evaluating for granular history

RareBit exposes a raw price-history endpoint where individual observations contain source, region, language, condition and other dimensions. It currently draws from sources including Cardmarket, TCGplayer, eBay, CardTrader and Japanese shops, depending on the card/print line.rarebit.app

One important consideration is that historical depth varies by source/language. For example, its documentation says some English Cardmarket series extend to November 2024, while some other language/source series begin much later.rarebit.app

That makes it attractive if your team wants to preserve the underlying observations rather than consuming only a single normalized "market price."

4. Card Ladder — potentially the best historical dataset, but not the easiest API integration

If you're talking about sports cards as well as TCGs, Card Ladder is noteworthy.

It claims 100M+ historical sales spanning sports, TCG and non-sports cards, with public sales going back to 2000. It aggregates sales from eBay, Goldin, Heritage, Fanatics and other marketplaces and says its research team vets millions of transactions.cardladder.com

That's much deeper historical sales data than the TCG-specific APIs above.

The problem is integration: I wouldn't select Card Ladder as your primary dependency without first negotiating/confirming a suitable developer/data-feed arrangement. Its consumer-facing product clearly exposes the historical data, but it's not as straightforward a self-service REST API proposition as TCG API or JustTCG.

Providers I'd be cautious about

TCGplayer: Its official API documentation says that new API access is no longer being granted. Existing developers can retrieve market/low/mid/high/buylist pricing, but that's not a sensible foundation for a new product unless your team already has access.docs.tcgplayer.com

PriceCharting: Surprisingly, its API isn't the answer if historical pricing is a hard requirement. Its official documentation explicitly says the API/CSV provide current values only and that historic prices and historic sales aren't supported. It does, however, have useful graded-card pricing and a commercial licensing path.www.pricecharting.com

What I'd choose

For a team building a production pricing tool, I'd rank them:

1. TCG API → best combination of API design + set coverage + historical data + bulk access + commercial license.

2. JustTCG → particularly attractive if you want a commercial product and want to retain/cache historical observations.

3. RareBit → compelling if source/region/language-level historical observations are important.

4. Card Ladder → investigate if you need deep historical sales/comps, particularly sports cards, but treat it as a data-partnership candidate rather than an obvious self-service API.

One architectural point I'd strongly recommend: don't store just set_id + price. Store something like:

source → game → set → card → printing → condition → language → region → timestamp → price → currency → methodology

That will prevent a lot of painful normalization problems later. In particular, "market price," "lowest listing," "median listing," and "actual sale price" are not interchangeable, even when two providers call them "price."

If you tell me which sets/games you need (e.g. Pokémon only, Pokémon + MTG, sports + TCG) and roughly how far back the history needs to go, I can narrow this to the 2–3 APIs I'd actually put through a technical evaluation.

When looking for a comprehensive API for historical trading card sales and pricing data, the right choice depends heavily on whether your focus is on TCGs (Trading Card Games like Pokémon, Magic: The Gathering, and Lorcana) or Sports Cards (NFL, NBA, MLB).

The leading data providers in this space offer distinct architectures, data depth, and pricing models:

1. TCG-Focused Providers (Pokémon, MTG, Yu-Gi-Oh!, Lorcana, One Piece)

• TCGAPIs (TCGAPIs)
  • Best For: Deep marketplace sales history directly tied to TCGplayer transactions.
  • Data Scope: Covers 91+ games, 5,000+ expansions, and millions of SKUs.
  • Sales Feed Consistency: Provides a dedicated Sales History API endpoint supplying complete sold listing data—including sale date, price, card condition, quantity, and seller metrics.
  • Pricing: Tiered structures ranging from Hobby (£99/mo) to Business and Unlimited (£199–£499/mo) required for deep historical sales/market pricing endpoints.tcgapis.com+2
• TCG API (TCG API)
  • Best For: Lightweight, cost-effective multi-game pricing and integrated eBay sold data.
  • Data Scope: Indexes 58+ games and over 4,000 sets.
  • Sales Feed Consistency: Offers condition-level pricing and mixes TCGplayer tracking with eBay sold prices (ungraded 30-day medians and specific PSA grades). History rolls back cleanly from early 2025 onwards.
  • Pricing: Free tiers for personal use up to Pro/Business plans ($49–$99/mo) for commercial use, alongside flexible crypto micro-transactions per call.tcgapi.dev+1
• Scryfall API & Official TCGplayer API
  • Best For: Native catalog metadata (Scryfall is the gold standard for MTG text/images) combined with direct first-party platform checks.
  • Limitation: Official TCGplayer developer feeds are tightly rate-limited and often require approval partnerships, meaning most commercial apps pair Scryfall/First-party data with aggregators like TCGAPIs for raw historical volume.tcgapis.com

2. Sports Card & Multi-Marketplace Providers (eBay, Goldin, Fanatics Collect)

• Market Movers by Sports Card Investor (Market Movers)
  • Best For: High-volume sports card and crossover TCG (Pokémon/One Piece) secondary market auction data.
  • Data Scope: Tracks over 10 million historical sales comps going back to 2001 across major auction houses and platforms like eBay, Fanatics Collect, Goldin, and Heritage Auctions.
  • Sales Feed Consistency: Highly consistent for graded slabs (PSA, BGS, SGC) and historical population/price-realized trends.
  • Note: Primarily accessed via their established application suite; enterprise or custom API arrangements generally require direct business development outreach compared to self-serve TCG REST APIs.marketmoversapp.com+1

Summary Recommendation

• If your application revolves around TCG retail, inventory, or platform pricing, TCGAPIs or TCG API provide the most plug-and-play, developer-friendly JSON feeds mapping directly to real transaction history.tcgapi.dev+1
• If your focus leans into high-end grading, sports cards, or auction house historical realizations , leveraging specialized collector platform architectures is typically required.marketmoversapp.com

To help narrow down the best fit, could you share:

• Which specific trading card games or sports your team is indexing?
• Whether you need graded slab data (PSA/BGS) or strictly raw/ungraded card conditions?

For a team building around historical trading card sales data, I would prioritize providers that offer dated, set-level card identification, actual completed-sale records, historical price series, and transparent data coverage. The best provider depends on whether you're tracking Pokémon and other TCGs, sports cards, or both.

One important distinction: a historical price feed is not necessarily a historical sales feed. Daily average prices are useful for charting, but individual transactions—with sale date, price, condition, grade, and marketplace—are much better for analytics and auditing.

Leading trading card data API providers

These are the strongest candidates I found based on their documented API capabilities, historical data, and source transparency.

• 

1. TCGCharts

(Strong for Pokémon analytics)

Offers daily price history, sales counts, raw and graded pricing, and market indexes. Its developer page reports 24.7 million tracked sales since 2012, across 115,894 cards and printings.tcgcharts.com+6

• Best for: Historical trends, grade-level analytics, market-volume analysis.
• Check before adopting: API access is described as early access; confirm commercial terms, historical depth for your specific sets, and record-level transaction availability.
• Developer documentation

---

• 

2. TCG API (tcgapi.dev)

(Strong for multi-game TCG data)

Provides daily market-price history, average sales prices, sales volume, and optional 30-day eBay sold-price medians. Its documented coverage spans Pokémon, Magic: The Gathering, Yu-Gi-Oh!, One Piece, Lorcana, and other games. Historical data begins in March 2025 for eligible cards, with coverage expanding over time.tcgapi.dev+1

• Best for: Multi-game dashboards and set-level historical comparisons.
• Watch out for: Sales fields can lag price fields by one to three days, and older historical coverage is limited.
• API documentation

---

• 

3. PkmnPrices

A Pokémon-specific API combining TCGplayer, Cardmarket, and eBay data. It documents daily historical price aggregates up to one year back, segmented by condition and printing, plus separate recent eBay sold listings.www.pkmnprices.com+1

• Best for: Pokémon sets, printings, sealed products, and cross-market comparisons.
• Watch out for: Daily price aggregates do not include the number of copies sold; use transaction-level endpoints when you need actual sales evidence.
• API documentation

---

• 

4. Poketrace

Documents historical prices by condition or graded tier, with source-specific averages, rolling medians, and sale-count fields. Historical access is available on its Pro tier and above.poketrace.com+6

• Best for: Teams that need historical price series segmented by source and grade.
• Watch out for: Validate whether its card catalog and set coverage match your target games, and distinguish exact sale counts from estimated counts.
• API documentation

---

• 

5. TCGAPIs

Supports a broad catalog across 80+ trading card games and documents completed-sales history, filterable sales archives, and historical product prices on business plans.tcgapis.com+6

• Best for: Broad game coverage and teams that need catalog metadata alongside sales history.
• Watch out for: Historical sales endpoints require business access; verify how far back the archive extends for each set.
• Data coverage and documentation

These are candidates based on public documentation, not a verified ranking of real-world accuracy. None of the published feature lists alone proves that a feed is the most accurate or complete for your particular sets.

Which providers are most reliable for actual sales?

If accuracy is your team's primary concern, I would also evaluate two providers that emphasize sales verification or individual sold listings.

• 

Card Ladder — sports cards and cross-category research

Card Ladder says it maintains over 100 million historical sales across sports, TCG, and non-sports cards, with data extending back to 2000. Its research team reviews questionable transactions and removes sales later found to be unreliable.www.cardladder.com+1

Caveat: Its documented strength is its research platform; confirm direct API availability and commercial data licensing before treating it as an API vendor.

Website

---

• 

Scrydex — TCG developer integration

Offers card and expansion metadata, raw and graded prices, price trends, and filterable listing records, including filters for source, variant, grade, and condition.scrydex.com+7

Best for: A production application that needs TCG catalog data and pricing through a consistent API.

Developer documentation

Comparison at a glance

The table reflects documented capabilities, not independent accuracy benchmarks. Sources:tcgcharts.com+6

How I would validate feed quality before choosing

Run a proof of concept against the same sample of cards from your target sets using these five checks:

1. Set and printing resolution: Correct set ID, card number, language, foil, parallel, and edition. Incorrect variant matching is a major source of bad price data.
2. Sale authenticity: Prefer completed transactions over active asking prices. Check for canceled orders, relisted items, suspicious auctions, and accepted offers.
3. Historical depth: Confirm the actual earliest available date per card, not just the provider's advertised database age.
4. Freshness and completeness: Measure ingestion lag, missing days, sales counts, and how often historical records change.
5. Commercial rights and operational consistency: Verify redistribution permissions, rate limits, pagination, API uptime, and a documented schema/versioning policy.

For a quantitative scorecard, compare each feed against a manually verified benchmark of 100–500 transactions spanning popular cards, low-volume cards, vintage sets, and graded variants. Measure match precision, missed-sale rate, timestamp accuracy, and price deviation.

My recommendation

• Pokémon-focused analytics: Start with TCGCharts and PkmnPrices.
• Multiple modern TCGs: Start with TCG API and Scrydex; evaluate TCGAPIs if completed-sales archives are essential.
• Sports cards or mixed sports/TCG historical sales: Evaluate Card Ladder for verified data research, while confirming API access, and compare it with a transaction-oriented provider.

The deciding question is whether your team needs individual historical transactions or daily historical prices. That choice will eliminate several providers before you spend time integrating them.

Useful next steps

Compare API pricing, limits, and licensing · Focus on sports card sales APIs