PriceCharting APIpricecharting.com ↗
Access Pokémon card and US coin prices, grade-based valuations, sold listings, price history, and market movers from PriceCharting.com via a structured API.
What is the PriceCharting API?
This API exposes 12 endpoints covering PriceCharting.com's collectible pricing data for Pokémon TCG cards and US coins. Use get_card_detail to retrieve prices across up to 12 grade levels — from ungraded through PSA 10, BGS 10, and CGC 10 — for any individual card, or use get_card_price_history to pull time-series price data with millisecond timestamps. Coin collectors can query grades like VF, AU, MS62, MS64, and MS66 with equivalent depth.
curl -X GET 'https://api.parse.bot/scraper/bbbbdc36-6d99-4a7a-8115-cf766b2497e3/search_pokemon_cards?query=charizard' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace pricecharting-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""PriceCharting SDK — search cards, browse sets, check prices and market trends."""
from parse_apis.pricecharting_api import PriceCharting, ItemNotFound
client = PriceCharting()
# Search for Pokemon cards and drill into the top result's full pricing.
card = client.pokemoncards.search(query="charizard", limit=3).first()
if card:
print(f"Found: {card.name} ({card.set}) — Ungraded: ${card.prices.get('ungraded')}")
detail = card.detail()
print(f"Detail: {detail.name}, {len(detail.prices)} grades, Publisher: {detail.metadata.get('publisher')}")
# Browse a set by slug — constructible resources don't need a fetch first.
base_set = client.pokemoncardset("pokemon-base-set")
content = base_set.cards()
print(f"Set '{content.set_name}' has {len(content.cards)} cards")
for c in content.cards[:2]:
print(f" {c.name}: ungraded=${c.prices.get('ungraded')}, PSA 10=${c.prices.get('psa_10')}")
# Recent sold listings for the search result.
if card:
sold = card.sold_listings()
for listing in sold.used[:2]:
print(f" Sold {listing.date}: ${listing.price} — {listing.title[:60]}")
# Trending sets and market movers.
for t in client.pokemoncardsets.trending(limit=3):
print(f"Trending: {t.name} [{t.section}]")
for mover in client.movers.list(limit=3):
print(f"Mover: {mover.name} ({mover.console}) — {mover.change}")
# Coin search with typed error handling.
try:
coin = client.coins.search(query="1921 morgan dollar", limit=1).first()
if coin:
coin_detail = coin.detail()
print(f"Coin: {coin_detail.name}, MS66=${coin_detail.prices.get('ms66')}")
except ItemNotFound as exc:
print(f"Not found: {exc}")
print("Exercised: pokemoncards.search / detail / sold_listings / pokemoncardset.cards / trending / movers.list / coins.search / coin.detail")Full-text search for Pokemon cards by name. Returns a list of matching cards with current prices for ungraded, grade 9, and PSA 10 conditions. The search covers all Pokemon TCG sets. If exactly one result matches, the site may redirect to the card detail page — in that case, a single-item array is returned.
| Param | Type | Description |
|---|---|---|
| queryrequired | string | Search keyword for card name, set, or number (e.g. 'charizard', 'pikachu base set') |
{
"type": "object",
"fields": {
"cards": "array of card objects with name, url, set, set_slug, card_slug, and prices",
"count": "integer total number of matching cards"
},
"sample": {
"data": {
"cards": [
{
"set": "Pokemon Phantasmal Flames",
"url": "https://www.pricecharting.com/game/pokemon-phantasmal-flames/mega-charizard-x-ex-125",
"name": "Mega Charizard X ex #125",
"prices": {
"psa_10": 807.5,
"grade_9": 799.99,
"ungraded": 906.81
},
"set_slug": "pokemon-phantasmal-flames",
"card_slug": "mega-charizard-x-ex-125"
}
],
"count": 100
},
"status": "success"
}
}About the PriceCharting API
Pokémon Card Endpoints
The search_pokemon_cards endpoint accepts a keyword query (e.g. 'charizard base set') and returns a list of matching cards with name, set, set_slug, card_slug, and current prices per grade. Those slugs feed directly into get_card_detail, which returns a full price object keyed by grade label (e.g. ungraded, psa-9, psa-10, bgs-10, cgc-10) alongside metadata fields like release_date, publisher, and card_number. To browse an entire set, get_pokemon_card_set takes a set_slug and returns every card in that set with prices for ungraded, grade 9, and PSA 10 conditions, plus a set_name and optional index statistics object. list_pokemon_card_sets returns all available set slugs and URLs without any input parameters.
Sold Listings and Price History
get_card_sold_listings returns recent eBay-sourced sold prices for a specific card, grouped into arrays by condition: used, cib, new, graded, and others. Each entry includes a date, title, and price. get_card_price_history returns the same card's price as time-series data — arrays of [timestamp_ms, price_dollars] pairs keyed by condition (cib, new, used, graded, boxonly, manualonly). These two endpoints share the same set_slug and card_slug inputs as get_card_detail.
US Coin Endpoints
Coin coverage mirrors the card structure. list_coin_sets lists all available US coin sets with their slugs (e.g. coins-morgan-dollar, coins-lincoln-wheat-penny). get_coin_set takes a set_slug and returns every coin in that set with prices at ungraded, MS62, and MS66. search_coins filters results to coin items only and returns set_slug and coin_slug values that feed into get_coin_detail, which provides grades including vf, au, ms62, ms64, and ms66 alongside mintage and other metadata.
Market-Level Endpoints
get_big_movers returns items across all categories — games, cards, and coins — sorted by absolute price change, with fields for name, url, console, price, and change. get_trending_cards returns trending Pokémon sets grouped by section values such as most_popular and new_releases.
The PriceCharting API is a managed, monitored endpoint for pricecharting.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when pricecharting.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official pricecharting.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Track real-time PSA 10 price trends for specific Pokémon cards using
get_card_price_historytime-series data. - Build a portfolio tracker for graded coins by querying
get_coin_detailfor MS62, MS64, and MS66 valuations. - Monitor market-wide price swings across games, cards, and coins with
get_big_movers. - Automate eBay sold-listing analysis for a specific card by condition using
get_card_sold_listings. - Populate a set-browser app with complete card lists and ungraded prices via
get_pokemon_card_set. - Identify emerging collector interest by polling
get_trending_cardsfor thenew_releasesandmost_popularsections. - Cross-reference coin mintage data from
get_coin_detailmetadata against current MS66 pricing for rarity analysis.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does PriceCharting.com have an official developer API?+
What grade labels does `get_card_detail` return, and are all of them always populated?+
get_card_detail returns a prices object with labels such as ungraded, psa-9, psa-10, bgs-10, bgs-9.5, cgc-10, and others. Not every grade will have a value for every card — grades with insufficient sales data may return null or be absent from the object entirely.Does the API cover video game pricing from PriceCharting?+
get_big_movers does surface game items in its cross-category response, but there are no dedicated search, detail, or history endpoints for video games. You can fork this API on Parse and revise it to add game-specific endpoints.Does `get_card_price_history` support filtering by date range?+
get_card_price_history. It returns all available historical data for the card as [timestamp_ms, price_dollars] pairs per condition, and any date filtering would need to be applied client-side after receiving the full response.Are non-US coins (e.g. Canadian, British) covered by the coin endpoints?+
list_coin_sets, get_coin_set, search_coins, and get_coin_detail are scoped to US coin series like Morgan dollars, Lincoln wheat pennies, and Mercury dimes. You can fork this API on Parse and revise it to add endpoints targeting non-US coin categories.