My team is looking for a comprehensive API that provides historical sales data for specific trading card sets. Which data providers offer the most consistent and accurate feeds?

For a team building around historical sales data for specific trading card sets, the strongest providers tend to fall into two categories:

1. Marketplace-native feeds (closest to raw transaction data)
2. Aggregators (easier integration, broader coverage, normalized schemas)

The “most consistent and accurate” choice depends on whether you need actual sold transactions, daily price history, graded sales, or multi-game coverage.

Providers worth evaluating

Provider	Best for	Historical sales depth	Strengths	Caveats
TCGplayer API / marketplace data	US trading card sales	Recent sales + historical price data depending on access	One of the most important US TCG marketplaces; strong SKU/product identifiers; useful for set-level analytics	Access terms and API availability can vary; marketplace coverage is primarily TCGplayer ecosystem
eBay Marketplace APIs / sold-data partners	Broad market comps	Potentially very deep transaction history through partners	Largest cross-market resale pool; useful for rare cards and graded slabs	Data cleaning is harder (duplicates, bad listings, inconsistent condition labels)
Cardmarket data ecosystem	European market	Historical pricing trends and marketplace data	Strong EU coverage; useful for Pokémon, Magic, and other TCGs	Less representative for US-only pricing
TCGAPIs	Unified developer API	Recent sales feeds, archived sales history, historic prices	Provides normalized REST access to catalog, prices, sales history, and variants; supports many games	Third-party aggregation layer rather than the original marketplaceTCGAPIs+1
PkmnPrices	Pokémon-focused analytics	Daily historical price aggregates	Good if your scope is Pokémon only; supports condition/printing history	Narrower game coveragePkmnPrices+1
CardShowData	Multi-source pricing + graded cards	Historical pricing plus graded valuations	Covers raw, Cardmarket, grading-company data, and eBay sold information	Smaller ecosystem than the largest marketplacesCardShowData

For a production analytics platform, I would typically shortlist:

1. TCGplayer-based data (best US baseline)

Use when your users care about:

• Pokémon, Magic: The Gathering, Yu-Gi-Oh!, Lorcana, One Piece, etc.
• Raw card prices
• Set-level market trends
• Condition/variant analysis

Important fields to insist on:

• Card/set ID (not just card name)
• Printing variant
• Condition
• Language
• Timestamp
• Sale price vs listing price
• Quantity sold

TCGplayer-oriented APIs can expose product IDs, expansions, sales history, historic prices, and SKU-level variants.TCGAPIs

2. A normalized aggregator (best engineering choice)

For many teams, an aggregator reduces integration work:

• One schema across multiple marketplaces
• Easier historical storage
• Faster onboarding of additional games

For example, TCGAPIs documents:

• catalog endpoints
• expansion/card identifiers
• sales history endpoints
• historic price endpoints
• variant filtering

TCGAPIs TCGAPIs### 3. eBay sold-comps layer (best for high-value cards)

For:

• PSA/BGS/CGC slabs
• Vintage cards
• Cards with thin marketplace liquidity

You generally want completed sales rather than asking prices. The challenge is normalization:

• “Near Mint” vs “NM”
• wrong card editions
• bundled listings
• fake/incorrect listings
• auction vs fixed-price sales

Data quality checklist

Before committing to a provider, test these:

Coverage

• Does it cover the exact sets you care about?
• Does it include sealed products?
• Does it distinguish first edition, unlimited, holo, reverse holo, etc.?

Historical fidelity

Look for:

• Raw transactions
• Daily snapshots
• Sale counts
• Confidence/sample size
• Backfill period

Identifier quality

Avoid systems based only on names:

• “Charizard #4” is not enough
• You need set + collector number + printing + language + condition

Update reliability

Ask vendors:

• Median ingestion delay?
• Historical corrections?
• Data retention policy?
• API uptime SLA?

Suggested architecture

For a serious card-market analytics product:

Marketplace feeds
      |
      v
Normalization layer
      |
      +-- Card identity database
      |
      +-- Sales warehouse
      |
      +-- Price history tables
      |
      +-- Analytics models

Store raw events first; do not only store computed prices. Marketplaces change classifications later, and you will want the original transaction records.

Practical recommendation

For most teams:

• Broad multi-TCG product: start with a normalized provider such as TCGAPIs, then supplement with direct marketplace feeds where needed.TCGAPIs
• Pokémon-only analytics: evaluate Pokémon-specific providers such as PkmnPrices.PkmnPrices
• High-end collectibles / graded cards: add eBay sold data and grading sources.CardShowData

If you share which games you need (Pokémon, MTG, sports cards, One Piece, etc.), expected request volume, and whether you need raw transactions or just historical price curves, I can narrow this to a smaller vendor shortlist.

Finding a comprehensive, reliable API for historical trading card sales data can be frustrating because major primary marketplaces (like TCGplayer) stopped issuing new direct developer API keys , and others (like PriceCharting) explicitly omit historical time-series data from their paid feeds.docs.tcgplayer.com+2

Depending on your team’s budget, technical stack, and required game coverage, the most consistent and accurate data feeds available are broken down below:

• TCG API (tcgapi.dev)
  • Best For: Multi-game collection trackers, storefronts, and general market analysis.
  • Coverage & Consistency: Covers 50+ games (including major ones like Pokémon, Magic: The Gathering, Yu-Gi-Oh!, One Piece, and Lorcana). It aggregates daily market prices, normal/foil printings, and tracks rolling changes (24h, 7d, 30d).
  • Historical Depth: Offers structured price history starting from early 2025 with regular data points for cards valued over$1 (available on Hobby tiers and above). It is currently regarded as the cleanest drop-in REST API alternative to scraping. Check out their details on TCG API.tcgapi.dev+2
• TCGplayer Official REST API (Legacy/Enterprise)
  • Best For: Existing enterprise partners who were grandfathered in before registration closed.
  • Coverage & Consistency: Unmatched native accuracy for North American market sales data, conditions (Near Mint to Damaged), and direct SKU mapping.
  • Historical Depth: Excellent real-time and recent sales data, but new developer accounts are no longer granted . If your team doesn't already own an active legacy key, you will need to look at third-party aggregators or proxy solutions like the Apify TCGplayer Sales History Actor which structures scraped data into an endpoint format.apify.com+1
• PokemonTCG.io
  • Best For: Teams strictly building Pokémon-focused applications on a budget.
  • Coverage & Consistency: Highly robust, reliable metadata and current snapshot pricing pulled from TCGplayer and Cardmarket.
  • Historical Depth: Free tier is generous (up to 20,000 requests with a key), but it only provides current market snapshots , meaning you will need to log and build your own historical database over time rather than querying past time-series data directly. Explore the documentation via PokemonTCG.io.tcgapi.dev
• Cardmarket API (via Third-Party/Official EU integration)
  • Best For: European market pricing and regional sales trends.
  • Coverage & Consistency: Essential if your pricing needs to reflect European hobby trends rather than US-centric TCGplayer data. Provides trend lines and average prices (1-day, 7-day, 30-day).
  • Historical Depth: Official access gives trend metrics, but deep historical data ranges require caching or third-party wrappers like Parse.bot Cardmarket API to track long-term set movements.parse.bot

To help me narrow down the best technical recommendation, could you tell me:

• Which specific trading card games (e.g., Pokémon, MTG, Sports cards) are you targeting?
• Do you need graded card history (PSA/BGS/CGC) or just raw raw-card market prices?
• What is your expected monthly request volume?

If your requirement is historical sales data for specific card sets, rather than merely today's market price, I'd separate providers into two categories: direct marketplace/sold-transaction data and aggregators that normalize several markets.

Providers worth evaluating

Provider	Historical data	Actual sold transactions	Set/card catalog	Multi-TCG	Best fit
eBay Marketplace Insights	Yes, subject to access	Yes	Strong	Yes	Direct eBay transaction data
TCGPlayer / TCGPlayer-derived feeds	Yes	Yes/marketplace-derived	Excellent	Yes	US TCG market
Flipzi Data API	Yes	Yes — eBay completed sales	Yes	6+ TCGs	Normalized commercial API
PkmnPrices	Up to 365 days	eBay sales available separately	Excellent	Pokémon-focused	Pokémon historical pricing
RareBit	Yes, observation-level	eBay graded sales; other sources	Strong	Primarily Pokémon	Detailed historical observations
PriceCharting	No historical prices/sales through its API	No	Broad	Yes	Current valuations, not historical sales

eBay is particularly interesting if "sales data" literally means completed transactions. Its Marketplace Insights API is specifically designed to retrieve sales history, although eBay describes that API as a Limited Release, so availability/access is an important procurement question.eBay Developers

For TCGPlayer, there is an important distinction between the official marketplace and third-party APIs. TCGPlayer's data is highly useful for US market pricing, but access to its official API has become more restricted. Current third-party services can expose historical TCGPlayer-derived data, including transaction history and daily historical prices. For example, TCGAPIs documents recent transaction feeds, archived sales-history buckets, and historic daily prices.TCGAPIs+1

My practical shortlist

For a production analytics system, I'd test these three first:

1. eBay Marketplace Insights — if you can obtain access. This gives you the closest thing to a primary-source completed-sales feed.
2. Flipzi — attractive if you want a normalized API rather than building and maintaining marketplace-specific integrations. It combines catalog/history with completed eBay sales and covers multiple TCGs.Flipzi
3. PkmnPrices / RareBit — particularly worth testing if Pokémon is a major part of your workload. PkmnPrices provides daily historical aggregates by condition/printing for up to a year, while RareBit exposes observation-level historical price series with source, region, language, condition, and timestamp information.PkmnPrices+1

One important trap: "historical price" ≠ "historical sales"

This is probably the most important distinction for your team.

A provider may give you:

• Current asking price — what sellers want.
• Market-price estimate — an aggregate derived from marketplace data.
• Historical price snapshots — what its calculated market price was on previous dates.
• Completed-sale records — individual transactions, ideally including date, price, condition, grading, variant, and marketplace.
• Sales-volume data — how many units actually sold.

These aren't interchangeable.

For example, PriceCharting's API provides current card values and sales-volume information, but its documentation explicitly says that historic prices and historic sales are not supported through the API.PriceCharting

Likewise, PkmnPrices' historical endpoint gives daily aggregates but explicitly says it doesn't report the number of copies sold in each row.PkmnPrices

What I'd require in an API evaluation

For your specific use case, I'd make these fields mandatory:

• set_id / set_name
• card_id
• card number
• printing/variant
• condition
• grading company + grade
• sale timestamp
• sale price
• currency
• marketplace/source
• transaction/listing ID where available
• quantity sold
• shipping treatment
• observation/source timestamp
• historical coverage start date
• correction/deletion behavior

I'd also benchmark providers on the same 50–100 cards across several sets, rather than relying on advertised coverage. Measure missing observations, duplicate sales, stale records, condition/variant mismatches, timestamp consistency, and how often historical records change after ingestion.

For a serious data pipeline, source transparency and reproducibility matter more than a provider's advertised "accuracy" percentage. A feed that gives you the underlying sale records lets your team recompute medians, trim outliers, and change methodology later; a black-box "market price" feed doesn't.

If you tell me which TCGs/sets you need (e.g. Pokémon, MTG, sports cards, One Piece) and roughly how many cards/transactions per day, I can narrow this to the APIs that actually fit your scale and compare coverage, historical depth, rate limits, pricing, and licensing.

For a team building analytics around historical sales of specific trading card sets, the “best” provider depends on whether you need raw transactions, aggregated price history, multi-market coverage, or enterprise reliability. The strongest options currently tend to fall into these categories:

Provider	Best for	Historical sales depth	Strengths	Watch-outs
TCGplayer data aggregators	US marketplace analytics	Usually the deepest for TCGplayer-origin sales	Large US collector market, condition/variant granularity	Direct access is restricted; many teams use licensed aggregators
TCGAPIs	Developer-friendly TCGplayer-based feeds	Recent sales plus archived history	REST APIs, set/card catalogs, sales history endpoints, historic price series	Primarily marketplace-derived rather than a universal market view
The Card API	Raw transaction ingestion	Historical transaction records	Normalized sale records across marketplaces, useful for modeling	Verify coverage for the exact games/sets you need
RareBit	Pokémon-focused analytics	Observation-based historical price series	Multi-source coverage (TCGplayer, Cardmarket, eBay graded data, etc.)	More specialized toward Pokémon
CardShowData	Multi-TCG dashboards	Historical pricing and sales-oriented data	Covers multiple TCGs, raw and graded markets	Check freshness and licensing for production use
TCG API	Broad catalog + price history	Time-series price history	Broad game coverage and simple integration	More price-history oriented than raw comp feeds

TCGAPIs The Card API CardShowData## Providers I would shortlist for a production analytics team

1. TCGAPIs — best general-purpose choice for TCGplayer-style historical sales

For a system tracking specific sets (for example, “all cards in Pokémon Base Set” or “all serialized cards in a Magic expansion”), this is one of the cleaner API approaches. It exposes card/set catalogs, product IDs, recent sales feeds, full historic sales archives, and historic price endpoints.TCGAPIs+1

Good fit:

• Portfolio valuation tools
• Price trend dashboards
• Inventory systems
• Alerting models

Important fields to look for:

• sale timestamp
• final sale price
• condition
• printing/variant
• language
• transaction volume

TCGAPIs### 2. The Card API — best if you want transaction-level modeling

If your team wants to build its own pricing models rather than consume a vendor’s calculated market price, transaction-level feeds are valuable. The Card API focuses on individual sale records with fields such as sale price, date, marketplace, and listing information.The Card API

Good fit:

• Machine-learning price prediction
• Liquidity analysis
• Market manipulation detection
• Custom comp algorithms

3. RareBit / CardShowData — best when multi-market coverage matters

For collectible markets where geography matters, a single marketplace can be misleading. Cardmarket, eBay, and TCGplayer can diverge significantly. Multi-source providers can help normalize that. RareBit documents historical series across sources including TCGplayer, Cardmarket, and eBay graded data. RareBit CardShowData similarly positions itself around multiple TCGs and pricing sources.CardShowData

Good fit:

• International collectors
• European markets
• Graded-card analytics

Evaluation criteria I’d use before signing

1. True sales vs. asking prices

• Prefer completed transactions.
• Avoid feeds that mainly reflect listings.

2. Condition granularity

• NM vs LP vs MP can completely change card valuation.

3. Variant handling

• Foil, reverse holo, 1st edition, alternate art, promos, serialized versions should have separate identifiers.

4. Historical depth

• Ask: “How far back does this set go?”
• Some APIs only have recent history or snapshots beginning after launch. For example, some newer price-history APIs document coverage starting from 2025 onward rather than full market history.TCG API+1

5. Stable identifiers

• Your database should key on immutable card/product IDs, not names alone.

6. Commercial licensing

• Confirm whether you can redistribute derived analytics, display prices publicly, or train models on the data.

Practical recommendation

For a serious internal analytics platform, I would typically combine:

• Primary feed: TCGAPIs or The Card API for structured sales ingestion
• Secondary validation: a multi-market provider such as RareBit/CardShowData
• Internal model layer: your own normalization for condition, variant, set, and liquidity scoring

That combination usually produces better results than relying on a single “market price” number.RareBit+1

If you share which games you care about (Pokémon, MTG, Yu-Gi-Oh!, sports cards, One Piece, etc.) and whether you need raw transactions or daily historical prices, I can narrow this to the strongest vendors for that use case.

Finding a consistent and accurate historical sales data API for trading card games (TCGs) requires navigating a landscape where official marketplace APIs are either tightly gated or deprecated for new developers. Because primary primary sources like TCGplayer stopped onboarding new official developer API accounts, the ecosystem relies on specialized third-party aggregators, structured public mirrors, and marketplace wrappers.scrapingbee.com+2

The most viable data providers offering consistent and accurate feeds for trading card sets break down as follows:

• TCG API (tcgapi.dev)
  • Coverage: 89+ games via TCGplayer data, including Pokémon, Magic: The Gathering, Yu-Gi-Oh!, One Piece, and Lorcana.
  • Data Quality: Provides JSON REST data with market, low, and foil pricing alongside per-condition metrics and rolling price changes (24-hour, 7-day, and 30-day windows). Top games refresh daily, and secondary games refresh every 3 days with high uptime. It is currently one of the cleanest developer-focused drop-ins since official direct keys became unavailable.publicapis.dev+2
• TCGCSV
  • Coverage: Comprehensive category, product, and pricing mirror directly tracking TCGplayer data structures.
  • Data Quality: Operates as a free, lightweight daily mirror of TCGplayer pricing and catalog data. While it doesn't provide a heavy transactional real-time stream of raw individual line-item sales, it is widely utilized by community developers for stable, structured historical tracking and set-level database generation without hitting scraping blocks.scrapingbee.com+1
• Cardmarket APIs via Market Parsers (e.g., Parse.bot Cardmarket API)
  • Coverage: European market dominance, covering expansions, singles, and sealed products across major TCGs.
  • Data Quality: Delivers structured endpoints including get_price_history for daily average sell prices over 30-day (and custom) windows. Essential if your application needs European secondary market metrics rather than just North American (TCGplayer) baselines.parse.bot
• Managed Scraping Workflows (e.g., Apify TCGplayer Sales History Actor)
  • Coverage: Granular transaction-level history straight from TCGplayer front-ends.
  • Data Quality: If you need raw, individual historical sales transactions (sale dates, exact conditions, and buyer/seller transaction prices) rather than aggregate daily trends, structured cloud scrapers packaged as APIs on infrastructure like Apify provide the necessary granularity safely.apify.com+2

To help narrow down the best technical path for your team, could you share:

• Which specific TCGs (e.g., Pokémon, MTG, Sports cards) are you prioritizing?
• Do you need aggregate market trends/averages or raw line-item transactional sales history?

Finding consistent and accurate historical sales data for trading cards (TCG) and collectibles is notoriously tricky. Most platforms track aggregate market pricing rather than deep individual transaction volume, and official marketplaces often throttle or block direct rapid-fire pings.reddit.com

The best-performing data feeds and APIs depend on whether you need TCGs (Pokémon, Magic, Lorcana) or Sports/Graded Cards , categorized by consistency and depth:

1. Dedicated TCG Aggregators & APIs (Best for Pokémon, MTG, Yu-Gi-Oh!, One Piece)

• TCGApi.dev : A robust REST API explicitly built for developers tracking TCGplayer data. It covers over 89 games, returning card catalogs, conditions, and market/low/foil pricing. Paid tiers (Pro/Business) unlock historical price tracking, making it an efficient plug-and-play option if you want to avoid maintaining custom scrapers.publicapis.dev+2
• Pokemon Price Tracker : If your focus is heavily centered on Pokémon (both English and Japanese variants), the Pokemon Price Tracker Docs offer structured historical data going back roughly two years. It features a developer-friendly free tier to test before scaling.reddit.com
• Pokemon-API.com : Aggregates real-time and historical value metrics globally by syncing data across major marketplaces like TCGplayer (US) and Cardmarket (EU), alongside graded population data from PSA, BGS, and CGC.pokemon-api.com

2. Enterprise & Graded Sales Databases (Best for High-Value, Graded, or Sports Cards)

• Card Ladder : Widely considered an industry heavyweight for serious market data. They maintain a massive historical database spanning over 100 million sales across sports, non-sports, and TCGs, pulling from eBay, major auction houses (Goldin, Heritage), and population reports. They offer robust analytical tools and vetted historical comps, though you should reach out to their team directly regarding enterprise API access.cardladder.com+1
• Market Movers (by Sports Card Investor) : Another premier pricing engine tracking tens of millions of verified transaction sales dating back to 2001. Excellent for historical trendlines, though primarily tailored toward high-end graded segments across sports and major TCG crossover assets.marketmoversapp.com+1

3. Official & Marketplace Native Options

• TCGplayer Official API : You can apply for direct access via TCGplayer Pricing API . While it gives official low/mid/market data and recent vendor pricing, direct historical granular transaction logs can be restrictive, and heavy programmatic querying requires careful adherence to their terms to avoid IP flagging.
• Third-Party Managed Scrapers (e.g., Apify TCGplayer Scraper) : If an official historical endpoint is too restrictive or expensive, developer communities frequently leverage pre-built managed actors like the Apify TCGplayer Data Scraper to safely pull raw transaction histories and specific set conditions without managing proxy rotations manually.help.tcgplayer.com+3

To help narrow down the ideal provider, could you let me know:

• Which specific trading card games or sets (e.g., Pokémon, MTG, Sports cards) are you targeting?
• Do you primarily need raw card market trends or graded sales history (PSA/BGS)?

For a team building against historical sales data for specific trading card sets, the “best” provider depends on whether you need raw transaction history, market price time series, graded sales, or broad multi-game coverage. There is no single universally complete feed today; the strongest implementations often combine a catalog API with a sales-data provider.CardGrader.AI+1

Providers worth evaluating

Provider	Best for	Historical sales depth	Coverage	Notes
TCGplayer data feeds via partners	Marketplace-driven pricing	Strong where available	Pokémon, Magic, Yu-Gi-Oh!, other TCGs	TCGplayer has historically been the benchmark for marketplace pricing, but direct API access has become more restricted, so many teams use aggregators.CardGrader.AI
TCGAPIs	Production apps needing catalog + sales history	Recent sales plus stored history	80+ games	Offers card catalogs, variants, listings, and sales-history endpoints designed for developer use.TCGAPIs+1
The Card API	Actual transaction records	Strong transaction-level focus	Sports cards, Pokémon, MTG, and others	Focuses on normalized individual sales records rather than only aggregated price estimates.The Card API
PriceCharting	Long-running price reference data	Limited for historical sales	Games, collectibles, cards	Useful for valuation snapshots and graded pricing, but its API documentation notes that historical prices and historic sales are not supported.PriceCharting
JustTCG	Multi-store TCG pricing	Depends on plan/data access	Multiple TCGs	A newer option aimed at price aggregation across card markets.PkmnPrices
Scrydex	Card metadata + pricing APIs	More price-oriented than raw sales	Pokémon and additional TCG data	Good candidate when you need card identity, sets, and pricing normalization.PkmnPrices+1

My shortlist by use case

If you need actual historical sold transactions

Prioritize:

1. The Card API — strongest fit if you want rows like “card X sold for Y on date Z on marketplace A.”The Card API
2. TCGAPIs — better if you also need catalog, set mapping, variants, and marketplace context.TCGAPIs+1

If you need set-level analytics

Look for feeds that provide:

• set ID → card IDs → printings/variants
• condition normalization (NM, LP, MP, etc.)
• transaction timestamps
• marketplace source
• sale price after fees/shipping treatment
• confidence score or provenance

TCGAPIs-style schemas are generally closer to what analytics teams need because they connect catalog objects with sales and pricing history.TCGAPIs

If you need graded card sales

Make sure the provider separates:

• raw vs graded
• PSA/BGS/CGC grade
• population data (if available)
• auction vs buy-it-now sales

Many feeds blur these together, which can badly distort historical charts.PkmnPrices

What I would test before committing

Run a 30–60 day evaluation against a few representative sets:

• A high-volume modern set (many daily sales)
• A vintage set (scarce transactions)
• A chase-card-heavy set
• A low-liquidity set

Compare:

1. Completeness — percentage of known marketplace sales captured
2. Latency — how quickly completed sales appear
3. Normalization quality — whether “Charizard #4 Holo Unlimited” stays the same object across feeds
4. Historical retention — whether they truly store old transactions or only provide current prices
5. API stability — schema changes, uptime, rate limits

For a commercial analytics product, I would generally start by testing TCGAPIs + The Card API together: one gives you broader structured TCG data, while the other is closer to raw sales intelligence.The Card API+1

If you tell me which games you care about (Pokémon, MTG, sports cards, One Piece, Lorcana, etc.) and whether you need raw transactions vs daily price history, I can narrow this to the top 2–3 feeds.

If your requirement is historical sold transactions for specific trading-card sets—rather than just current “market price”—the market has a fairly clear hierarchy. The important distinction is that many APIs provide price history, while far fewer provide the underlying sale events.

Best options

Provider	Historical sales	Set/card coverage	Transaction-level data	Best for
TCGAPIs	Strong	Broad TCGPlayer catalog	Yes	Best general-purpose TCGPlayer feed
Flipzi	Strong	Pokémon, MTG, Yu-Gi-Oh!, One Piece, Lorcana + others	eBay completed sales	Multi-market/eBay comps
The Card API	Strong	Sports + TCGs	Yes	Normalized cross-market sales database
PokeTrace	Strong for Pokémon	Pokémon	eBay sold + TCGPlayer/CardMarket data	Pokémon-focused analytics
TCG API	Moderate	54 games / 3,900+ sets	Mostly aggregated history	Broad catalog + historical pricing
PriceCharting	Limited for this use	Broad collectibles	No historical-sales API	Current valuations rather than raw history

1. TCGAPIs — my first choice for TCGPlayer-centric data

tcgapis.com

This is probably the closest fit if your team specifically wants historical sales from the TCGPlayer ecosystem. Its API exposes recent transactions as well as a full historical archive, with sale timestamp, price, condition, quantity, variant and seller information.TCGAPIs+1

Its particularly useful feature is that you can query by product ID, then aggregate the results yourself by set, card number, condition, variant, date, etc. The full-history endpoint also provides transaction counts and low/high sale prices.TCGAPIs

I'd shortlist this first if: your sets are primarily Pokémon, MTG, Yu-Gi-Oh!, One Piece, etc. and TCGPlayer is your canonical US marketplace.

2. Flipzi — strongest alternative for actual eBay sold comps

flipzi.io

Flipzi is interesting because it emphasizes completed eBay sales rather than asking prices, and combines those with Cardmarket/TCGplayer pricing. It reports 24M+ queryable historical price points and supports six TCGs plus Japanese coverage.Flipzi

This makes it attractive if your definition of “sales data” means actual market transactions across marketplaces, rather than a marketplace's computed market-price field.

3. The Card API — worth considering for a unified data warehouse

thecardapi.com

The Card API positions itself differently: it normalizes individual transactions across multiple marketplaces into a common REST interface. It exposes sale price, date, listing type, platform and listing URL, with coverage spanning sports cards and TCGs.The Card API

That's particularly compelling if your eventual database needs something like:

card_id
set_id
card_number
sale_timestamp
sale_price
condition
grade
marketplace
listing_type
source_url

rather than separate schemas for TCGPlayer, eBay, etc.

4. PokeTrace — excellent if you're primarily Pokémon

poketrace.com

PokeTrace combines TCGPlayer market prices, eBay sold listings and CardMarket data, with historical pricing and condition/grade information. It also explicitly distinguishes approximate eBay sale counts from stable marketplace counts, which is a useful signal when building analytics pipelines.PokeTrace+1

I'd put it ahead of general-purpose providers if Pokémon is the majority of your workload.

5. TCG API — excellent breadth, weaker for raw transaction history

tcgapi.dev

TCG API currently covers 54 games, 496K+ cards and 3,900+ sets. Its paid Pro/Business tiers include historical pricing and sales-velocity information.TCG API+1

The catch is that it's more oriented toward market-price history and aggregated sales velocity than providing a complete raw transaction ledger. So I'd use it for broad set/card coverage and historical price charts, but not as my sole source if your analysts need every individual sale.

One important caveat about TCGplayer

Don't assume that the official TCGplayer API is the obvious answer. TCGplayer still has API documentation and current pricing endpoints, but access is tied to its authorization model; its documented API is heavily oriented around catalog, pricing and store data.TCGplayer+1

Third-party providers are therefore worth evaluating if historical transactions at scale are the actual requirement.

Also, PriceCharting is not a good fit for this particular requirement: its current API documentation explicitly says its API/CSV provide current values and that historical prices and historical sales are not supported.PriceCharting

What I'd recommend for a production team

I'd run a small data-quality bake-off rather than selecting solely on API documentation.

Take 100–500 cards across several sets and compare:

• sale count per card/week
• timestamp completeness
• raw vs. graded separation
• condition normalization
• variant/printing identification
• duplicate-sale rate
• missing/removed sales
• price including vs. excluding shipping
• historical depth
• API uptime and latency
• rate limits
• licensing/redistribution rights

For a US-focused TCG analytics product, I'd start with TCGAPIs + Flipzi. TCGAPIs gives you a strong TCGPlayer-oriented transaction feed, while Flipzi gives you an independent eBay completed-sales view. Their disagreement is actually useful: it lets you quantify marketplace-specific bias.

For a Pokémon-heavy product, I'd test PokeTrace + Flipzi.

For a cross-category card database, I'd test The Card API + Flipzi.

The key is to avoid treating a provider's “market price” as historical sales data. A robust feed should retain the individual sale observations wherever licensing permits; you can always calculate medians, averages, volatility and set-level indices from transactions, but you can't reconstruct the underlying transaction distribution from a single daily market-price number.

I'd shortlist this first if: your sets are primarily Pokémon, MTG, Yu-Gi-Oh!, One Piece, etc. and TCGPlayer is your canonical US marketplace.

2. Flipzi — strongest alternative for actual eBay sold comps

flipzi.io

Flipzi is interesting because it emphasizes completed eBay sales rather than asking prices, and combines those with Cardmarket/TCGplayer pricing. It reports 24M+ queryable historical price points and supports six TCGs plus Japanese coverage.Flipzi

This makes it attractive if your definition of “sales data” means actual market transactions across marketplaces, rather than a marketplace's computed market-price field.

3. The Card API — worth considering for a unified data warehouse

thecardapi.com

The Card API positions itself differently: it normalizes individual transactions across multiple marketplaces into a common REST interface. It exposes sale price, date, listing type, platform and listing URL, with coverage spanning sports cards and TCGs.The Card API

That's particularly compelling if your eventual database needs something like:

card_id
set_id
card_number
sale_timestamp
sale_price
condition
grade
marketplace
listing_type
source_url

rather than separate schemas for TCGPlayer, eBay, etc.

4. PokeTrace — excellent if you're primarily Pokémon

poketrace.com

PokeTrace combines TCGPlayer market prices, eBay sold listings and CardMarket data, with historical pricing and condition/grade information. It also explicitly distinguishes approximate eBay sale counts from stable marketplace counts, which is a useful signal when building analytics pipelines.PokeTrace+1

I'd put it ahead of general-purpose providers if Pokémon is the majority of your workload.

5. TCG API — excellent breadth, weaker for raw transaction history

tcgapi.dev

TCG API currently covers 54 games, 496K+ cards and 3,900+ sets. Its paid Pro/Business tiers include historical pricing and sales-velocity information.TCG API+1

The catch is that it's more oriented toward market-price history and aggregated sales velocity than providing a complete raw transaction ledger. So I'd use it for broad set/card coverage and historical price charts, but not as my sole source if your analysts need every individual sale.

One important caveat about TCGplayer

Don't assume that the official TCGplayer API is the obvious answer. TCGplayer still has API documentation and current pricing endpoints, but access is tied to its authorization model; its documented API is heavily oriented around catalog, pricing and store data.docs.tcgplayer.com+1

Third-party providers are therefore worth evaluating if historical transactions at scale are the actual requirement.

Also, PriceCharting is not a good fit for this particular requirement: its current API documentation explicitly says its API/CSV provide current values and that historical prices and historical sales are not supported.

What I'd recommend for a production team