Pokemon Card Price API with Full Price History (Free Tier)

For Pokemon card prices, PokemonTCG.io is the best free option — 1,000 requests a day with no key, 20,000 with one — and it returns both TCGPlayer and Cardmarket prices, but only a current snapshot. If you need price history, per-condition pricing, or games beyond Pokemon, you need a paid API.

Most Pokemon card APIs will hand you a card’s current market price. Far fewer will tell you what it was worth last month, what it sells for in Lightly Played rather than Near Mint, or whether it moved 12% this week — and those are usually the numbers a price tracker, a collection valuer or a store tool actually needs.

This guide covers every major Pokemon card API available in 2026 and is specific about where each one stops: which return prices at all, which break them out per printing and per condition, which keep history, and which are free. It ends with working code for a price lookup.

If you are here because you searched for a PriceCharting, PokemonWizard or PokemonPriceTracker API, skip to that section — the short version is that one of the three does not publish an API and another excludes historical prices.

Why Pokemon Card Pricing Data Matters

The Pokemon TCG market has grown dramatically. Booster boxes, elite trainer boxes, and individual singles all fluctuate in value based on tournament results, content creator openings, and market sentiment. Developers building for this market need:

• Current prices — What is a card worth today?
• Price history — Is a card trending up or down?
• Multiple printings — Normal, Holofoil, Reverse Holo, and special variants all have different values
• Set-level data — Which sets have the highest expected value?
• Sealed product pricing — Booster boxes and ETBs are investments too

Let’s look at the APIs available.

Pokemon TCG APIs Compared

PokemonTCG.io

PokemonTCG.io is the go-to API for Pokemon card data. It’s free, well-documented, and has a large community.

What it offers:

• Complete Pokemon card database with set info, HP, attacks, abilities
• Card images (high and low resolution)
• TCGPlayer price data (market, low, mid, high)
• Advanced search with filters (type, set, rarity, etc.)
• No authentication required for basic use

Limitations:

• Pokemon only — no other games
• Prices are a daily snapshot — no per-condition breakdown
• No price change tracking or historical price trends
• No price movers or market analytics
• Its cardmarket block can lag well behind its tcgplayer block — checking a card on 26 August 2026 returned tcgplayer.updatedAt: 2026/08/26 but cardmarket.updatedAt: 2026/07/01. Read the timestamp before trusting the EU price.

The card API endpoint reference has the full /v2/cards payload field list if you want to see exactly what comes back.

• Rate limited to 20,000 requests per day (generous but fixed)

Best for: Apps that need rich Pokemon card data (images, attacks, HP, types) and basic pricing as a secondary feature.

// PokemonTCG.io example
const response = await fetch(
  'https://api.pokemontcg.io/v2/cards?q=name:charizard&pageSize=5',
  { headers: { 'X-Api-Key': 'your-api-key' } }
);
const data = await response.json();
data.data.forEach(card => {
  console.log(`${card.name} (${card.set.name})`);
  console.log(`  Market: $${card.tcgplayer?.prices?.holofoil?.market || 'N/A'}`);
});

Pokemon Price Trackers & Scrapers

Several sites like PriceCharting and Pokemon price tracker apps offer pricing data, but most don’t provide a public API. They’re useful for manual lookups but not for building applications.

Limitations:

• Most don’t offer developer APIs
• Data is often scraped and redistribution rights are unclear
• No standardized format
• Single-game focus

TCG API

TCG API is built specifically for card pricing. It covers Pokemon alongside 53 other games, with a focus on daily-refreshed market data.

What it offers:

• Market pricing from TCGPlayer, refreshed daily for Pokemon
• Separate prices for Normal, Holofoil, Reverse Holofoil, and other printings
• Price change tracking (24h, 7d, 30d percentage and dollar changes)
• Price movers — biggest gainers and losers
• Card search with game, set, and name filters
• Bulk price data for large-scale applications (Pro tier)
• 54 games, not just Pokemon

Limitations:

• Less detailed card metadata than PokemonTCG.io (no attack text, HP, weakness, etc.)
• No card images hosted (links to TCGPlayer)
• Free tier limited to 100 req/day (paid plans available)

Best for: Price tracking, collection valuation, deal finding, and any app where knowing what a card is worth matters more than knowing its attack damage.

Getting Started with TCG API for Pokemon

Let’s build a quick price lookup tool. First, sign up for a free API key.

Search for Cards

const API_KEY = 'your-api-key';
const BASE_URL = 'https://api.tcgapi.dev/v1';

async function searchPokemonCards(query) {
  const url = `${BASE_URL}/search?q=${encodeURIComponent(query)}&game=pokemon&per_page=5`;
  const response = await fetch(url, {
    headers: { 'X-API-Key': API_KEY }
  });
  return (await response.json()).data;
}

const cards = await searchPokemonCards('charizard ex');
cards.forEach(card => {
  console.log(`${card.name} — ${card.set_name}`);
});

Get Detailed Prices

Each card comes with prices broken down by printing:

async function getCardPrices(cardId) {
  // /v1/cards/{id} returns the card row only — prices live on /prices,
  // which returns the array of printings directly as `data`.
  const response = await fetch(`${BASE_URL}/cards/${cardId}/prices`, {
    headers: { 'X-API-Key': API_KEY }
  });
  const printings = (await response.json()).data;

  console.log(`\n${printings[0]?.card_name ?? cardId}\n`);

  for (const p of printings) {
    const market = p.market_price ? `$${p.market_price.toFixed(2)}` : 'N/A';
    const low = p.low_price ? `$${p.low_price.toFixed(2)}` : 'N/A';
    // price_change_24h is a percentage, not a dollar amount
    const change = p.price_change_24h != null
      ? ` (${p.price_change_24h >= 0 ? '+' : ''}${p.price_change_24h.toFixed(2)}% 24h)`
      : '';

    console.log(`  ${p.printing}: Market ${market} | Low ${low}${change}`);
  }
}

Output:

Charizard ex (Obsidian Flames)

  Normal: Market $12.45 | Low $10.50 (+2.89% 24h)
  Holofoil: Market $45.99 | Low $39.00 (-2.55% 24h)

Track Price Changes

Find which Pokemon cards are moving the most:

// top-movers returns a flat array; pick gainers or losers with `direction`
async function movers(direction) {
  const response = await fetch(
    `${BASE_URL}/prices/top-movers?game=pokemon&direction=${direction}&period=24h&limit=5`,
    { headers: { 'X-API-Key': API_KEY } }
  );
  const { data } = await response.json();

  data.forEach(card => {
    const pct = `${card.price_change >= 0 ? '+' : ''}${card.price_change.toFixed(1)}%`;
    console.log(`  ${card.name} — $${card.market_price.toFixed(2)} (${pct})`);
  });
}

console.log('Top Gainers (24h):');
await movers('up');
console.log('\nTop Losers (24h):');
await movers('down');

Build a Simple Price Checker

Here’s a complete Node.js script you can run from the command line:

const API_KEY = 'your-api-key';
const BASE_URL = 'https://api.tcgapi.dev/v1';

const query = process.argv.slice(2).join(' ');
if (!query) {
  console.log('Usage: node price-check.js <card name>');
  process.exit(1);
}

const url = `${BASE_URL}/search?q=${encodeURIComponent(query)}&game=pokemon&per_page=5`;
const response = await fetch(url, {
  headers: { 'X-API-Key': API_KEY }
});
const cards = (await response.json()).data;

if (cards.length === 0) {
  console.log(`No Pokemon cards found for "${query}"`);
  process.exit(0);
}

cards.forEach(card => {
  console.log(`\n${card.name} (${card.set_name})`);
  const market = card.market_price ? `$${card.market_price.toFixed(2)}` : 'N/A';
  console.log(`  ${card.printing}: ${market}`);
});

Run it:

node price-check.js pikachu vmax
node price-check.js "umbreon vmax alt art"
node price-check.js charizard

Looking for a PriceCharting, PokemonWizard or PokemonPriceTracker API?

These three come up constantly in searches for Pokemon price data. Here is what each actually offers, checked against their own documentation in August 2026.

PriceCharting

PriceCharting covers video games, comics and trading cards, and its Prices API returns values across grades and conditions — including PSA and BGS tiers that most card APIs ignore. Two limits matter if you are building a price tracker:

• No historical data. Their documentation is explicit: the API and CSV “only support current item values in various grades and conditions. Historic prices and historic sales are not supported.”
• No free tier. “You must have a paid subscription to access the API.”

If you need to chart what a card did over the last 90 days, their API cannot produce it.

PokemonWizard

PokemonWizard is a consumer site — collection portfolios, price alerts, a market index, prices updated hourly. It is genuinely useful for collectors.

It does not publish a public API. There is no developer documentation, no advertised endpoints, and nothing in its sitemap (checked August 2026). If you landed here searching for “PokemonWizard API price history”, that is why you could not find one.

PokemonPriceTracker

PokemonPriceTracker is the closest match to what most people are after: daily TCGPlayer prices for 50,000+ English and Japanese cards across all conditions, plus PSA/CGC/BGS/SGC grading ROI and a set EV calculator. Its API has a free tier of 100 credits/day, $9.99/month for higher limits and $99/month for commercial use. History depth is tiered — 3 days free, 6 months on Pro, 12+ months on Business. If you work only with Pokemon and want grading ROI, it is a strong fit.

Side by side

The gap TCG API fills is the combination: price history and per-condition pricing over the same REST endpoints, across 54 games rather than Pokemon alone — so a multi-game tool does not need a separate integration per game.

Which Pokemon API is actually free, and what are the limits?

“Free” means different things across these APIs, and the difference is usually a rate limit rather than a price tag. Verified against each provider’s own documentation on 26 August 2026:

PokemonTCG.io’s free tier is genuinely generous and it is the right answer for a lot of projects. If all you need is card data plus a daily price snapshot, 1,000 requests a day with no signup at all is hard to beat, and 20,000/day once you register a key is more than most side projects will ever use.

So when is our free tier the better choice?

Honestly: not on raw request volume — 100/day is lower than their 1,000/day. The free tier here is sized for evaluating the API, not running on. Where it wins is on what a request returns:

• Price history. PokemonTCG.io gives you today’s snapshot. If you need to chart a card over 90 days, you would have to poll it daily and store the results yourself, starting from zero. Our history is already there.
• Per-printing rows. Normal and Foil come back as separate rows with their own market, low and median, rather than one price per product.
• 54 games from the same endpoints, if Pokemon is not the only game you support.

If none of those matter to your project, use PokemonTCG.io. That is a real recommendation, not a rhetorical setup.

Getting a PokemonTCG.io API key

Requests without authentication still work — their docs note that unauthenticated requests do not fail, the limits are just much lower. To raise them, register at dev.pokemontcg.io and send the key as an X-Api-Key header.

Convenient detail if you end up calling both: they document X-Api-Key and we document X-API-Key, and since HTTP header names are case-insensitive those are the same header. Only the key value changes, so a client that talks to one needs almost no rework to talk to the other.

Choosing the Right API

Use PokemonTCG.io if your app needs detailed card metadata — attacks, abilities, HP, weaknesses, resistances, types, and card images. It’s the best free source for the “data side” of Pokemon cards.

Use TCG API if your app needs accurate pricing — market values, price trends, and deal-finding. Especially useful if you also want to support other games like Magic or Yu-Gi-Oh! without integrating separate APIs for each.

Use both together for the ultimate Pokemon card app. Pull card data and images from PokemonTCG.io, and pricing from TCG API. Many developers take this approach.

For more on this comparison, see our detailed PokemonTCG.io comparison page.

Common errors and how to handle them

A few things trip people up when they first wire a Pokemon price lookup into a production app.

429 Too Many Requests

The Pokemon ecosystem is bursty — a tournament result or Jake’n’Bake video can send hundreds of users searching for the same card at once. TCG API’s free tier is 100 requests/day, enforced at UTC midnight. If you see 429s in production logs, check X-RateLimit-Remaining before each request and cache aggressively. A one-minute in-memory cache of popular card lookups will cut your actual API calls by 90% in any realistic app.

Card returns no price (prices: null)

This happens for three reasons: the card has no active TCGPlayer listings; the card is foil-only but you queried for printing=Normal; or the card is a sealed product you didn’t filter out. Always guard for prices being null and show a graceful “no pricing data available” state rather than crashing.

Alt-art variants are different card IDs

Pokemon alt arts — for example the Umbreon VMAX alt art from Evolving Skies — are tracked as separate cards with separate IDs. Searching for “Umbreon VMAX” returns both the standard and alt-art entries. Filter on rarity or full card name if you need one specific printing.

Stale prices after a market event

New Pokemon sets launch on a published schedule. If you are building anything time-sensitive around launch day (a pre-order price tool, a “what flipped overnight” tracker), plan for the fact that our daily refresh may run before or after the major reprint-info drop. Paid Pro tier gets you the top-movers endpoint which updates independently and catches these spikes faster.

Related Resources

• Build a Pokemon Price Tracker in 15 Minutes — Hands-on tutorial with watchlist and price alerts
• Pokemon on TCG API — All Pokemon sets and data
• Search API Reference — Full-text search documentation
• Price Data — Price endpoints and change tracking
• Bulk Data — Download prices for entire sets at once

Get Started

Ready to add Pokemon card prices to your app? Sign up for a free TCG API key and follow the quickstart guide to make your first API call. The free tier includes 100 requests per day — enough to build and test your integration. When you’re ready to scale, paid plans start at $9.99/month.

Building something cool with Pokemon card data? Share it with us on Discord — we love seeing what developers build.