TCG Pricing APIReal-time card prices for 8 trading card games

JSON REST API with TCGPlayer market data, real eBay sold-listing data, and PSA / BGS / CGC graded prices — all in one response.

View docs

curl "https://api.tcgpricelookup.com/v1/cards/search?q=charizard&game=pokemon" \
  -H "X-API-Key: YOUR_API_KEY"

Response

{
  "data": [
    {
      "id": "019535a1-d5d0-7c12-a3e8-b7f4c6d8e9a2",
      "tcgplayer_id": 510327,
      "name": "Charizard ex",
      "number": "006/197",
      "rarity": "Double Rare",
      "variant": "Standard",
      "image_url": "https://cdn.tcgpricelookup.com/pkmn/sv03/006.jpg",
      "set":  { "slug": "obsidian-flames", "name": "Obsidian Flames" },
      "game": { "slug": "pokemon",         "name": "Pokemon"         },
      "prices": {
        "raw": {
          "near_mint": {
            "tcgplayer": { "market": 48.97, "low": 42.50 },
            "ebay":      { "avg_7d": 50.75 }
          }
        },
        "graded": {
          "psa": {
            "10": { "ebay": { "avg_7d": 418.50 } }
          }
        }
      },
      "updated_at": "2026-02-16T12:00:00Z"
    }
  ],
  "total": 47,
  "limit": 20,
  "offset": 0
}

Powering tcgpricelookup.com, a top-ranked TCG price checker.

300,000+

Cards indexed

Trading card games

PSA / BGS / CGC

Graded values

TCGPlayer + eBay

Price sources

24/7

Updated continuously

Everything in one response

One call returns market price, eBay sold-listing data, and graded values across 10 PSA / BGS / CGC grades. No three different APIs.

GET /v1/cards/search?q=charizard&game=pokemon

{
  "data": [
    {
      "id": "019535a1-d5d0-7c12-a3e8-b7f4c6d8e9a2",
      "tcgplayer_id": 510327,
      "name": "Charizard ex",
      "number": "006/197",
      "rarity": "Double Rare",
      "variant": "Standard",
      "image_url": "https://cdn.tcgpricelookup.com/pkmn/sv03/006.jpg",
      "set":  { "slug": "obsidian-flames", "name": "Obsidian Flames" },
      "game": { "slug": "pokemon",         "name": "Pokemon"         },
      "prices": {
        "raw": {
          "near_mint": {
            "tcgplayer": { "market": 48.97, "low": 42.50 },
            "ebay":      { "avg_7d": 50.75 }
          }
        },
        "graded": {
          "psa": {
            "10": { "ebay": { "avg_7d": 418.50 } }
          }
        }
      },
      "updated_at": "2026-02-16T12:00:00Z"
    }
  ],
  "total": 47,
  "limit": 20,
  "offset": 0
}

↳ field 1
TCGPlayer market price
"market": 48.97
↳ field 2
Real eBay sold-listing avg
"avg_7d": 50.75
↳ field 3
PSA / BGS / CGC graded values
"10": { "ebay": { "avg_7d": 418.50 } }

Quickstart in 5 minutes

From signup to your first card lookup, in five steps.

1
Sign up for free
Click the Get an API Key button at the top of this page. No credit card. 10 seconds via email or social login.
2
Copy your API key
Your key is created and copied to your clipboard with one click. Store it in an environment variable.
```
export TCG_API_KEY="tk_live_..."
```

Make your first call

Search any card by name across all 8 supported games.

curl "https://api.tcgpricelookup.com/v1/cards/search?q=charizard&game=pokemon" \
  -H "X-API-Key: $TCG_API_KEY"

Parse the response

Every card comes with raw and graded prices in one JSON payload.

const { data } = await res.json();
const card = data[0];
console.log(card.name, card.prices.raw.near_mint.tcgplayer.market);

5
Build something
You're ready. Build a deck builder, portfolio tracker, marketplace integration, Discord bot — anything that needs live card prices. The same data powering tcgpricelookup.com.

Official open-source tools

Two MIT-licensed packages on npm — a typed JavaScript / TypeScript SDK and a command-line tool — both maintained at github.com/TCG-Price-Lookup.

JS / TS SDK

@tcgpricelookup/sdk

Official TypeScript SDK with full typed responses, auto-chunked batch lookup, typed errors (AuthenticationError, PlanAccessError, RateLimitError, ...) and optional retry-on-429. Native fetch, zero runtime dependencies, ESM + CJS. Works in Node 18+, browsers, Cloudflare Workers, Bun, and Deno.

Install

npm install @tcgpricelookup/sdk

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

const tcg = new TcgLookupClient({ apiKey: process.env.TCG_API_KEY });
const { data } = await tcg.cards.search({ q: "charizard", game: "pokemon" });

View on npm·Source on GitHub

CLI

tcglookup

Command-line tool for everyone — collectors, traders, shop owners, anyone who lives in a terminal. Pretty colored tables by default, --json flag for jq pipes, sparkline price-history, friendly typed errors with stable exit codes. Stores your key safely under XDG_CONFIG_HOME with file mode 600.

Install

npm install -g tcglookup

# one-time
tcglookup auth login

# every day
tcglookup search "charizard" --game pokemon
tcglookup history <card-id> --period 30d
tcglookup sets pokemon

View on npm·Source on GitHub

All official open-source code on GitHub

Both packages are MIT-licensed. Issues, pull requests, and feature requests are welcome at the org — github.com/TCG-Price-Lookup.

Visit org

What's included

Every endpoint, field, and feature included with the API.

Real-time TCGPlayer market, low, mid, high prices
eBay sold-listing data (7d / 30d averages) — Trader plan and above
PSA, BGS, CGC graded prices, grades 1–10 — Trader plan and above
Batch lookup via search?ids= for portfolios and watchlists
Per-condition pricing (Near Mint → Damaged)
Price history endpoints — Trader plan and above
Search by name, set, rarity, ID
8 games: Pokemon, Pokemon JP, MTG, Yu-Gi-Oh!, One Piece, Lorcana, SWU, FAB
JSON REST over HTTPS
X-RateLimit-* headers for proactive backoff
Free tier, no credit card
Commercial license available

Endpoints

Five REST endpoints covering search, card details, price history, sets, and games. Batch lookup is built into the search endpoint.

GET/v1/cards/search

Search cards

Full-text search across all 8 supported games. Filter by name, set, or game. Batch lookup by passing a comma-separated list of card IDs via the ids parameter.

curl "https://api.tcgpricelookup.com/v1/cards/search?q=charizard&game=pokemon" \
  -H "X-API-Key: YOUR_API_KEY"

GET/v1/cards/{id}

Single card details

Get the full data for one card by ID, including all conditions, all graded values, and metadata.

curl "https://api.tcgpricelookup.com/v1/cards/019535a1-d5d0-7c12-a3e8-b7f4c6d8e9a2" \
  -H "X-API-Key: YOUR_API_KEY"

GET/v1/cards/{id}/history

Price history

Historical price points for any card. Daily granularity. Track market trends, build charts. Trader plan and above.

curl "https://api.tcgpricelookup.com/v1/cards/{id}/history?period=30d" \
  -H "X-API-Key: YOUR_API_KEY"

GET/v1/sets

Browse sets

List every set across all games, or filter by game with the game query parameter. Includes release date, card count, and set slug.

curl "https://api.tcgpricelookup.com/v1/sets?game=pokemon" \
  -H "X-API-Key: YOUR_API_KEY"

GET/v1/games

List games

Get every supported trading card game with its slug and catalog size. Use the slug to filter search and sets queries.

curl "https://api.tcgpricelookup.com/v1/games" \
  -H "X-API-Key: YOUR_API_KEY"

Code recipes

Common things developers build with the TCG Pricing API. Copy, paste, run.

Track price changes for a watchlist

Poll multiple cards in one request with the search endpoint's ids parameter, store today's prices, diff against yesterday's snapshot.

curl "https://api.tcgpricelookup.com/v1/cards/search?ids=ID1,ID2,ID3" \
  -H "X-API-Key: $TCG_API_KEY"

Calculate the value of a card collection

Sum the market price of every card in a portfolio. Pass all card IDs through the search endpoint and reduce over the response.

curl "https://api.tcgpricelookup.com/v1/cards/search?ids=$(cat ids.txt | paste -sd ,)" \
  -H "X-API-Key: $TCG_API_KEY" | jq '[.data[].prices.raw.near_mint.tcgplayer.market] | add'

Poll a card for live price updates

Refresh a card's market price on a 30-second loop. Good for active watchlists without needing a streaming transport.

while true; do
  curl -s "https://api.tcgpricelookup.com/v1/cards/$CARD_ID" \
    -H "X-API-Key: $TCG_API_KEY" | jq '.prices.raw.near_mint.tcgplayer.market'
  sleep 30
done

Compare raw vs PSA 10 prices for grading premium

Show how much a graded slab is worth over the raw card. Useful for grading ROI calculators. Requires the Trader plan or above for graded data.

curl "https://api.tcgpricelookup.com/v1/cards/{id}" \
  -H "X-API-Key: $TCG_API_KEY" | \
jq '{ raw: .prices.raw.near_mint.tcgplayer.market,
       psa10: .prices.graded.psa["10"].ebay.avg_7d }'

Get all foil cards from a Pokemon set

Filter the search endpoint by set + variant. Returns every foil printing in the set with prices.

curl "https://api.tcgpricelookup.com/v1/cards/search?game=pokemon&set=obsidian-flames&variant=foil&limit=100" \
  -H "X-API-Key: $TCG_API_KEY"

Build a 30-day price history chart

Pull daily price points for the last 30 days and plot them. The history endpoint returns date-indexed market values. Trader plan and above.

curl "https://api.tcgpricelookup.com/v1/cards/{id}/history?period=30d" \
  -H "X-API-Key: $TCG_API_KEY"

What you can build

Six things developers actually build with the TCG Pricing API.

Deck builder app

Build a deck builder for any TCG with live market prices on every card. Show the deck cost in real time as users add cards.

/cards/search/cards/search?ids=

Portfolio tracker

Let collectors track the value of their collection over time. Pull batched prices nightly via search?ids=, store snapshots, chart trends.

/cards/search?ids=/cards/{id}/history

Marketplace integration

Power auto-pricing for a card marketplace. Pull TCGPlayer + eBay sold-listing data and suggest competitive listing prices.

/cards/search/cards/{id}

Investment analytics

Slab-grading ROI calculators, portfolio performance vs market index, raw-vs-graded premium analysis. PSA/BGS/CGC data is included.

/cards/{id}/cards/{id}/history

Discord / Twitch bot

Build a /price <card> command for any TCG community. One API key, one HTTP call, every game supported out of the box.

/cards/search

Inventory management

Local card shop POS, online inventory sync, eBay listing automation. Batch up to 20 IDs per search?ids= call and chunk larger inventories.

/cards/search?ids=/cards/{id}

Every game, one API

Eight TCGs indexed deeply. One auth header, one base URL, one JSON shape across all of them.

Pokemon

game=pokemon

30,000+ cards

Largest community. Hot graded market. PSA 10 premiums on every card.

Pokemon Japan

game=pokemon-jp

20,000+ cards

Japanese-exclusive sets, often appreciating before Western release.

Magic: The Gathering

game=mtg

100,000+ cards

Deepest catalog, 100k+ cards. Reserved list, formats, every printing.

Yu-Gi-Oh!

game=yugioh

40,000+ cards

Tournament meta moves prices fast. Refresh frequently to catch swings.

One Piece

game=onepiece

6,000+ cards

Newest hot TCG. Set releases drive aggressive price swings.

Disney Lorcana

game=lorcana

3,000+ cards

Disney IP, growing fast. New sets every quarter.

Star Wars: Unlimited

game=swu

2,500+ cards

Star Wars Unlimited. Early in its lifecycle, low coverage elsewhere.

Flesh and Blood

game=fab

8,000+ cards

Flesh and Blood. Premium prints, low-supply specialty cards.

Built for developers

REST over HTTPS

Plain JSON endpoints you can hit with any HTTP client. Poll on your own cadence, or use our recommended refresh windows.

JSON-first

Clean, predictable response shapes. Every field is documented. No XML, no surprises.

Stable versioned endpoints

All endpoints live under /v1/. Breaking changes go to /v2/, never to existing routes.

Build it yourself or use the API

What it really takes to scrape TCG prices yourself, vs what the API gives you out of the box.

Build it yourself

TCG Price Lookup API

Setup time

Build yourself

2-4 weeks of scraping, parsing, infra

With the API

5 minutes to first request

Proxy infrastructure

Build yourself

$200-500 / month

With the API

Included

Captcha & bot detection

Build yourself

$50-200 / month + ongoing fights

With the API

Included

Condition normalization

Build yourself

Weeks of edge cases per game

With the API

Done — Near Mint to Damaged, every game

eBay sold-listing data

Build yourself

Constantly breaks when listings change

With the API

7d / 30d averages, refreshed continuously

PSA / BGS / CGC graded values

Build yourself

Three separate scrapers + reconciliation

With the API

One endpoint, all grades 1-10

Multi-game support

Build yourself

One scraper per game, 8 sets of edge cases

With the API

One JSON shape across 8 games

Rate limits & retries

Build yourself

Hand-tuned exponential backoff per source

With the API

Handled — published per-tier quotas

Maintenance burden

Build yourself

Ongoing — every TCGPlayer/eBay UI change

With the API

Zero

Real cost (Year 1)

Build yourself

$3,000-8,000 in infra + dev time

With the API

$0 - $1,080 / year

Plans

Free tier with no credit card. Commercial license on paid plans.

Free

$0.00/month

200 requests / day · non-commercial

200 requests / day
Standard rate limits
All supported games
Raw condition prices
TCGPlayer prices
Non-commercial use
Community support

Start Free

Trader

$14.99/month

10,000 requests / day · commercial use

10,000 requests / day
High rate limits
All supported games
All raw conditions
TCGPlayer + eBay prices
Graded prices (PSA/BGS/CGC)
Price history & trends
Commercial use
Email support

Start Building

Business

$89.99/month

100,000 requests / day · commercial use

100,000 requests / day
Higher rate limits
All supported games
Everything in Trader
Priority support
Custom integrations
Potential partnership

Start Building

See full plan details →

What is a TCG pricing API?

Background, sourcing, and what you get instead of scraping it yourself.

A TCG pricing API is a programmatic way to fetch live trading card prices — market value, recent sales, condition-by-condition pricing, and graded slab values — without scraping the underlying marketplaces yourself. Apps, marketplaces, deck builders, portfolio trackers, and tournament tools all need fresh card prices, and a pricing API is what makes that practical at scale.

Where the prices come from

Card prices live in two main places: marketplace listings (where the cards are actively for sale) and sold-listing history (what they actually transacted at). The TCG Price Lookup API combines both. For every card, you get TCGPlayer market, low, mid, and high prices in every condition from Near Mint to Damaged, plus eBay sold-listing averages over rolling 7- and 30-day windows. For graded cards, you get PSA, BGS, and CGC values across grades 1 through 10, sourced from real sold slabs — not estimates.

Why “current price” is harder than it looks

Pricing a single card is genuinely complicated. The same card can have a dozen variants (1st edition, shadowless, holo, reverse holo, promo printings), eight conditions, and three or four grading companies each with ten grades. Multiply that across a 300,000+ card catalog spanning eight games, and you have a normalization problem that takes months to solve from scratch. The API gives you the normalized output: one canonical card record, every variant, every condition, every grade, in one JSON response.

What you avoid by using an API instead of scraping

Rolling your own scraper means standing up proxy infrastructure, solving captchas, parsing HTML that breaks every few weeks, handling rate limits that get aggressive when you exceed them, and reconciling condition strings (“LP”, “Lightly Played”, “light play”, “NM-”) into a single canonical scheme. That’s before you even touch graded data, where certified populations and sold-slab averages live across separate sites with their own anti-bot measures. Most teams that try this find the data layer ends up costing more developer time than the product they were trying to ship.

Who uses a TCG pricing API

Independent developers building deck builders and portfolio trackers, TCG marketplaces auto-pricing inventory, local card shops syncing prices across their POS and online listings, investment analytics platforms tracking grading premiums, Discord and Twitch bots answering “what is this card worth” in chat, and researchers studying secondary-market dynamics. The common thread is needing fresh prices on demand, across multiple games, without building (and maintaining) the data pipeline themselves.

How fresh is the data

Marketplace prices and sold-listing averages refresh continuously throughout the day. Card metadata and new set additions are updated as releases hit. The same data feeds tcgpricelookup.com, which is used directly by collectors every day — so the freshness bar is set by real consumer expectations, not API tier marketing.

Frequently asked questions

Common questions about the TCG Pricing API.

Yes. The TCG Price Lookup API has a Free tier that lets you search cards and read current prices without a credit card. The Free tier is for non-commercial use; commercial use requires the Trader or Business plan.

Eight games: Pokemon, Pokemon Japan, Magic: The Gathering, Yu-Gi-Oh!, One Piece, Disney Lorcana, Star Wars: Unlimited, and Flesh and Blood. Each game's full set catalog is indexed with per-condition prices.

Sign up for a free API key, then call GET https://api.tcgpricelookup.com/v1/cards/search?q=<name>&game=<game> with an X-API-Key header. The response is JSON and includes TCGPlayer market prices on every plan; eBay sold-listing averages and graded values are returned on Trader and Business plans.

Yes, on the Trader and Business plans. Card responses on paid plans include graded values for PSA, BGS, and CGC across grades 1 through 10 where available, sourced from real eBay sold listings. The Free plan returns raw TCGPlayer prices only.

Not yet. The API is REST-only today, and the recommended real-time pattern is to poll /v1/cards/{id} on a 15-30 second interval for active watchlists. A streaming transport is on the roadmap — see the Realtime Integration Patterns docs for the polling strategy and how to keep your client transport-agnostic so you can upgrade later.

Commercial use is included on the Trader and Business plans. The Free tier is non-commercial. Commercial usage covers things like resale apps, deck builders with monetization, marketplace integrations, and graded-card analytics products.

Rate limits depend on your plan. Free: 200 requests/day. Trader: 10,000 requests/day. Business: 100,000 requests/day. Batch lookups via search?ids= let you fetch multiple cards in a single request. See the Plans section above for current quotas.

TCGPlayer market data and eBay sold-listing averages are refreshed continuously throughout the day. Card metadata and set additions are updated as new sets release. The same data feeds tcgpricelookup.com, the consumer price checker.

Yes — two official open-source packages, both MIT-licensed and live on npm. `@tcgpricelookup/sdk` is the JavaScript / TypeScript SDK with full typed responses, auto-chunked batch lookup, typed errors, and optional retry-on-429. `tcglookup` is the command-line tool — `npm install -g tcglookup` then `tcglookup search "charizard"` from any terminal. Source code lives at https://github.com/TCG-Price-Lookup. The API is also plain JSON over HTTPS, so any HTTP client (curl, fetch, requests, axios) works without an SDK.

Each price block contains rolling averages of real eBay sold listings (e.g. 7-day and 30-day averages), separated by condition for raw cards and by grade for slabs. This is in addition to TCGPlayer market data — both sources are returned in the same response.

Pass your API key in the `X-API-Key` header on every request. The format is `X-API-Key: YOUR_API_KEY`. Never expose your key in client-side JavaScript — proxy requests through a backend you control.

200 for successful requests, 400 for malformed query parameters, 401 for missing or invalid API keys, 403 for plan-level access denials (e.g. requesting graded data on the Free tier), 404 for cards or sets that don't exist, 429 when you exceed your daily quota or burst rate limit, and 5xx for upstream issues. Every error response includes a JSON `error` field describing what went wrong.

Yes. Responses include `X-RateLimit-Limit` (your tier's daily quota) and `X-RateLimit-Remaining` (calls left in the current window). Use these to back off proactively rather than waiting for a 429.

On a 429, back off before retrying — at least a few seconds on Free, a second or two on Trader/Business. For 5xx responses, retry with exponential backoff starting at 1 second, capping at 30 seconds, with jitter. For high-volume workflows, batch card IDs via search?ids= so one call covers many cards against your daily quota.

Pass a comma-separated list of card IDs to /v1/cards/search via the `ids` parameter — e.g. `/v1/cards/search?ids=id1,id2,id3`. This returns all matching cards in one response and counts as a single call against your daily quota. Use it for portfolio refreshes, watchlist snapshots, and inventory syncs. Up to 20 IDs per request.

Webhooks and streaming price-change events are on the roadmap. Today the recommended pattern is to poll /v1/cards/{id} on a 15-30 second loop for active watchlists, or 60-120 seconds for background pages. See the Realtime Integration Patterns docs for the full backoff strategy.

Yes, and you should. Marketplace prices don't change every second, so caching responses for 5 to 60 minutes is reasonable for most apps. Card metadata (name, set, image) is even more cache-friendly — it can be cached indefinitely and refreshed when a new set drops. Use the `updated_at` field on each card to tell when the underlying data last changed.

Each variant is its own card record with its own ID and its own price block. A 1st Edition Charizard, an Unlimited Charizard, and a Shadowless Charizard are three separate entries — same name, same set, different IDs and different prices. Use the `variant` field to distinguish them.

Yes. The full OpenAPI 3 spec is published in the developer docs and auto-generates SDKs, request validators, and type definitions in any language you want. The docs site at /docs/api-reference is rendered directly from this spec.

On Free and Trader plans we ask for a small `Powered by TCG Price Lookup` link somewhere visible in your app or site. On Business and partnership plans this is optional. Either way, no attribution is required when the API is used purely server-side (e.g. for internal analytics or pricing automation).

Glossary

Trading card and API terms used throughout this site.

TCGPlayer market price: The algorithmic average sale price for a card on TCGPlayer, weighted by recent transactions. The closest thing the hobby has to a single canonical 'current price' for raw cards.
Low / Mid / High prices: The lowest, median, and highest active listings for a card on TCGPlayer. Useful for showing the price range a buyer or seller can expect.
eBay sold-listing average: The average actual sale price across recent eBay sold listings for a card. Reflects what buyers really paid, not what sellers are asking. The API exposes 7-day and 30-day rolling averages.
Near Mint / Lightly Played / Moderately Played / Heavily Played / Damaged: Standard condition tiers used to grade raw (un-slabbed) trading cards. Each condition prices independently — Near Mint is the most valuable for the same card.
Foil / Holo / Reverse Holo: Card variants with reflective treatments. Holo refers to the picture area; reverse holo to the card's background. Foils almost always trade at a premium over non-foil printings.
Raw card: A trading card that has not been graded or encapsulated by a third-party grading service. Sold by condition (Near Mint to Damaged).
Graded card / Slab: A card that has been authenticated, graded on a 1–10 scale, and sealed in a tamper-evident plastic case ('slab') by a grading company like PSA, BGS, or CGC. Graded cards are priced separately from raw cards and almost always at a premium.
PSA / BGS / CGC: The three major third-party grading services for trading cards. PSA (Professional Sports Authenticator) and BGS (Beckett Grading Services) are the longest-established; CGC (Certified Guaranty Company) entered TCG grading more recently. The TCG Price Lookup API returns values from all three.
Grading premium: The price difference between a raw card and the same card in a high grade (typically PSA 10). For chase cards, the premium can be 5–20×, which is what makes grading economically interesting.
Set / Expansion: A batch of cards released together as a product line. Most TCGs ship multiple sets per year. Each card in the API has a `set_name` and `set_slug` so you can filter by set.
1st Edition / Unlimited / Shadowless: Pokemon-specific printing variants. 1st Edition cards are the very first print run of a set; Unlimited is the later wide release; Shadowless refers to a very early Base Set printing without the drop shadow on the card art. Each variant prices independently.
REST API: An architectural style for web APIs where each resource (cards, sets, prices) has a stable URL and standard HTTP verbs (GET, POST) operate on it. The TCG Price Lookup API is REST over HTTPS, returning JSON.
Batch lookup: Fetching many cards in one request by passing a comma-separated list of IDs to /v1/cards/search via the ids parameter. Used for portfolio refreshes, watchlists, and inventory syncs. Up to 20 IDs per call.
Rate limit: The maximum number of API requests you can make in a given time window. The TCG Price Lookup API publishes per-tier daily quotas and returns X-RateLimit-Limit and X-RateLimit-Remaining headers so your app can back off proactively.
API key: A secret token that authenticates your requests. You get one for free at sign-up. Pass it in the X-API-Key header on every request, and never expose it in client-side code.

Start building

Get a free API key and start fetching prices in minutes.

Read the docs

TCG Pricing APIReal-time card prices for 8 trading card games

Everything in one response

Quickstart in 5 minutes

Sign up for free

Copy your API key

Make your first call

Parse the response

Build something

Official open-source tools

@tcgpricelookup/sdk

tcglookup

What's included

Endpoints

Search cards

Single card details

Price history

Browse sets

List games

Code recipes

Track price changes for a watchlist

Calculate the value of a card collection

Poll a card for live price updates

Compare raw vs PSA 10 prices for grading premium

Get all foil cards from a Pokemon set

Build a 30-day price history chart

What you can build

Deck builder app

Portfolio tracker

Marketplace integration

Investment analytics

Discord / Twitch bot

Inventory management

Every game, one API

Built for developers

REST over HTTPS

JSON-first

Stable versioned endpoints

Build it yourself or use the API

Plans

Free

Trader

Business

What is a TCG pricing API?

Where the prices come from

Why “current price” is harder than it looks

What you avoid by using an API instead of scraping

Who uses a TCG pricing API

How fresh is the data

Frequently asked questions

Glossary

Start building